Una [categoría de tema]

tabla de picadillo

Dos [dificultad de la pregunta]

medio

Tres [número de tema]

128. Secuencia consecutiva más larga

Cuatro [descripción del título]

Dada una matriz de números enteros sin ordenar, encuentre la longitud de la secuencia más larga de números consecutivos (no se requiere que los elementos de la secuencia sean consecutivos en la matriz original).
Diseñe e implemente un algoritmo con complejidad de tiempo O(n) para resolver este problema.

Cinco [ejemplo de tema]

Ejemplo 1:
- Entrada: números = [100,4,200,1,3,2]
- Salida: 4
- Explicación: La secuencia continua más larga de números es [1, 2, 3, 4]. Tiene longitud 4.
Ejemplo 2:
- Entrada: números = [0,3,7,2,5,8,4,6,0,1]
- Salida: 9

Seis [mensaje de tema]

$10^5$
$10^9 <= números[i] <= 10^9$

Siete [ideas para resolver problemas]

La idea de usar tablas hash
Primero agregue los elementos en la matriz a la tabla hash, el propósito de esto es eliminar la duplicación y facilitar los cálculos posteriores.
Luego recorra cada elemento en la tabla hash, calcule la matriz continua a partir de este elemento y explore la tabla hash
De esta manera solo usamos $O (n)$ tiempo de complejidad para resolver este problema
Finalmente devuelve el resultado.

Ocho 【Frecuencia de tiempo】

Complejidad del tiempo: $O (n)$ , $n$ es la longitud de la matriz entrante
Complejidad espacial: $O (n)$ , $n$ es la longitud de la matriz entrante

Nueve [implementación de código]

Versión del lenguaje Java

class Solution {
    
    
    public int longestConsecutive(int[] nums) {
    
    
        HashSet<Integer> map = new HashSet<>();
        for(int i = 0;i < nums.length;i++){
    
    
            map.add(nums[i]);
        }
        int res = 0;
        for(int num : map){
    
    
            if(!map.contains(num - 1)){
    
    
                int curNum = num;
                int curLen = 1;
                while(map.contains(curNum + 1)){
    
    
                    curNum += 1;
                    curLen += 1;
                }
                res = Math.max(res, curLen);
            }
        }
        return res;
    }
}

Versión en lenguaje C

struct HashNode
{
    
    
    int key;
    UT_hash_handle hh;
};

int longestConsecutive(int* nums, int numsSize)
{
    
    
    struct HashNode* map = NULL;
    struct HashNode* tempNode = NULL;
    for(int i = 0;i < numsSize;i++)
    {
    
    
        HASH_FIND_INT(map, &nums[i], tempNode);
        if(tempNode == NULL)
        {
    
    
            struct HashNode* newNode = (struct HashNode*)malloc(sizeof(struct HashNode));
            newNode->key = nums[i];
            HASH_ADD_INT(map, key, newNode);
        }
    }
    struct HashNode *val, *temp;
    int res = 0;
    HASH_ITER(hh, map, val, temp)
    {
    
    
        if(val != NULL)
        {
    
    
            int lastVal = val->key - 1;
            HASH_FIND_INT(map, &lastVal, tempNode);
            if(tempNode == NULL)
            {
    
    
                int curNum = val->key + 1;
                int curLen = 1;
                HASH_FIND_INT(map, &curNum, tempNode);
                while(tempNode != NULL)
                {
    
    
                    curNum += 1;
                    curLen += 1;
                    HASH_FIND_INT(map, &curNum, tempNode);
                }
                res = fmax(res, curLen);
            }
        }
    }
    HASH_ITER(hh, map, val, temp)
    {
    
    
        HASH_DEL(map, val);
        free(val);
    }
    return res;
}

Versión en lenguaje Python

class Solution:
    def longestConsecutive(self, nums: List[int]) -> int:
        map = set(nums)
        res = 0
        for num in map:
            if num - 1 not in map:
                curNum = num
                curLen = 1
                while curNum + 1 in map:
                    curNum += 1
                    curLen += 1
                res = max(res, curLen)
        return res

Versión del lenguaje C++

class Solution {
    
    
public:
    int longestConsecutive(vector<int>& nums) {
    
    
        unordered_set<int> map;
        for(int i = 0;i < nums.size();i++){
    
    
            map.insert(nums[i]);
        }
        int res = 0;
        for(const int& num : map){
    
    
            if(!map.count(num - 1)){
    
    
                int curNum = num;
                int curLen = 1;
                while(map.count(curNum + 1)){
    
    
                    curNum += 1;
                    curLen += 1;
                }
                res = max(res, curLen);
            }
        }
        return res;
    }
};