Use a fila de prioridade para resolver o tipo de dados construído por você mesmo - resolva o problema ganancioso

Pelo que entendi, a maior parte do problema ganancioso está relacionado à fila limitada.No último artigo, escrevi (16 mensagens) usando a fila prioritária para resolver o tipo de dados construído por mim.

Depois disso, analisei a questão do Leetcode hoje, que é uma típica questão gananciosa.

1054. Códigos de barras com distâncias iguais

Dificuldade Média 129 Favoritos e Compartilhamentos Mude para o inglês para receber feedback dinâmico

Num armazém, existe uma fila de códigos de barras, onde  i está o primeiro código de barras  barcodes[i].

Reorganize esses códigos de barras para que dois códigos de barras adjacentes não possam ser iguais. Você pode retornar qualquer resposta que atenda a esse requisito e a pergunta terá uma resposta garantida.

Exemplo 1:

Entrada: códigos de barras = [1,1,1,2,2,2]
 Saída: [2,1,2,1,2,1]

Exemplo 2:

Entrada: códigos de barras = [1,1,1,1,2,2,3,3]
 Saída: [1,3,1,3,2,1,2,1]

dica:

• 1 <= barcodes.length <= 10000
• 1 <= barcodes[i] <= 10000

Passa 15.242 Compromete 36.321

———————————————

Solução: Na verdade, o título é uma espécie de ordenação, para que os desiguais fiquem adjacentes. Isso é um pouco ganancioso e é natural pensar em uma solução: Dividir em grupos diferentes de acordo com o valor do número, e cada um tempo do grupo de valores diferentes Selecione o maior número até que todas as seleções sejam feitas.

Com o heap máximo da fila de prioridade, o código a seguir pode ser escrito.

class Solution {
    typedef pair<int,int> PSI;
    struct cmp
    {
        bool operator()(PSI a, PSI b)
        {
            return a.second<b.second;
        }
    };
public:
    vector<int> rearrangeBarcodes(vector<int>& barcodes) {
       priority_queue<PSI,vector<PSI>,cmp> pq;
        vector<int> ans;
        unordered_map<int,int> Hashmap;
        int n=barcodes.size();
        for(int i=0;i<n;i++)
        {
            Hashmap[barcodes[i]]++;
        }
        for (auto p : Hashmap) {
	        int front = p.first;   //key
            int end = p.second;   //value
            pq.push({front,end});
        }
        while(!pq.empty())
        {
            if(ans.empty() || ans[ans.size()-1]!=pq.top().first)
            {
                ans.push_back(pq.top().first);
                int front = pq.top().first;   //key
                int end = pq.top().second-1;   //value
                pq.pop();
                if(end>0)
                {
                    pq.push({front,end});
                }
            }
            else
            {
                PSI temp =pq.top();
                pq.pop();
                ans.push_back(pq.top().first);
                int front = pq.top().first;   //key
                int end = pq.top().second-1;   //value
                pq.pop();
                if(end>0)
                {
                    pq.push({front,end});
                }
                pq.push(temp);
            }
            
        }
        return ans;
    }
};

 

Resultados do:

passar

mostrar detalhes

Ver exemplo de código

Adicionar notas

Tempo de execução: 88 ms, superando 61,47% dos usuários em todos os envios de C++

Consumo de memória: 43 MB, superando 17,43% dos usuários em todos os envios de C++

Casos de teste aprovados: 58/58

O tipo de dados autoconstruído e o método de classificação são usados ​​​​acima, e a parte de pré-processamento usa hashmap para contar o número de ocorrências de cada elemento.