leetcode 347 C++ y solución kotlin

347. Elementos de alta frecuencia Top K

medio

1,6K

negocio relacionado

Dada una matriz de números enteros  nums y un número entero  k , devuelva  k el elemento con la frecuencia más alta. Puede devolver las respuestas en  cualquier orden  .

Ejemplo 1:

Entrada: números = [1,1,1,2,2,3], k = 2
 Salida: [1,2]

Ejemplo 2:

Entrada: números = [1], k = 1
 Salida: [1]

pista:

• 1 <= nums.length <= 105
• k El rango de valores es [1, 数组中不相同的元素的个数]
• Los datos de la pregunta garantizan que la respuesta sea única, en otras palabras, el conjunto de los primeros elementos de alta frecuencia en la matriz  k es único.

Avanzado: la complejidad temporal del algoritmo que diseñe  debe  ser mejor que  O(n log n) donde  n está el tamaño de la matriz.

Primero en la versión C ++, la idea básica es usar el mapa hash para contar el número de ocurrencias y luego mantener un montón mínimo de tamaño K. La función de comparación del montón mínimo usa la frecuencia como valor de comparación. Finalmente, basta con atravesar este montón mínimo. Utiliza datos de pares personalizados y funciones de comparación.

class Solution {
    typedef pair<int,int> PSI;
    struct cmp
    {
        bool operator()(PSI a, PSI b)
        {
            return a.second>b.second;       // 最小堆
        }
    };
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {

        priority_queue<PSI,vector<PSI>,cmp> pq;
        
        int n=nums.size();
        unordered_map<int,int> Hashmap;
        for(int i=0;i<n;i++)
        {
            Hashmap[nums[i]]++;
        }
        for (auto iter = Hashmap.begin(); iter != Hashmap.end(); ++iter) 
        {
            if(pq.empty() || pq.size()<k){
                pq.push({iter->first,iter->second});
            }
            else if(pq.size()>=k){
                int front = pq.top().first;   //key
                int end = pq.top().second;   //value
                if(iter->second>end){
                    pq.pop();
                    pq.push({iter->first,iter->second});
                }
            }
        }
        vector<int>ans;
        while(!pq.empty())
        {
            ans.push_back(pq.top().first);
            pq.pop();
        }
        return ans;
    }
};

Si usa kotlin, use la siguiente solución:

Ideas para resolver problemas:

1. Primero cuente la frecuencia de aparición de cada elemento y utilice una tabla hash para las estadísticas, donde la clave es el valor del elemento y el valor es el número de apariciones.
2. Convierta los pares clave-valor en la tabla hash en una lista de correspondencias entre los valores de los elementos y los tiempos de aparición.
3. Ordena la lista en orden descendente de apariciones.
4. Toma los valores de los primeros k elementos y devuélvelos.

La complejidad temporal de este algoritmo es $O(n \log n)$, donde $n$ es la longitud de la matriz. La complejidad temporal de la operación de inserción de la tabla hash es $O(1)$, la complejidad temporal de la clasificación es $O(n \log n)$ y la complejidad temporal de la eliminación de los primeros k elementos es $O(k )$ . La complejidad del espacio es $O(n)$.

class Solution {
    fun topKFrequent(nums: IntArray, k: Int): IntArray {
        val map = mutableMapOf<Int, Int>()
        for (num in nums) {
            map[num] = map.getOrDefault(num, 0) + 1
        }

        val list = mutableListOf<Pair<Int, Int>>()
        for (entry in map.entries) {
            list.add(Pair(entry.key, entry.value))
        }

        list.sortByDescending { it.second }
        val result = mutableListOf<Int>()
        for (i in 0 until k) {
            result.add(list[i].first)
        }

        return result.toIntArray()
    }
}

El uso de Kotlin aprovecha al máximo varias funciones de biblioteca y conversión directa de datos y, de hecho, es mucho más conciso de escribir.