[トピックカテゴリ] 1 つ

ハッシュ表

２【問題難易度】

中くらい

3 [トピック番号]

128. 最長連続シーケンス

4 【タイトル説明】

ソートされていない整数配列 nums を指定して、連続する数値の最長シーケンスの長さを見つけます (シーケンスの要素が元の配列で連続している必要はありません)。
この問題を解決するには、時間計算量が O(n) のアルゴリズムを設計して実装してください。

5 【トピック例】

例 1:
- 入力: 数値 = [100,4,200,1,3,2]
- 出力: 4
- 説明: 最も長く連続する数字のシーケンスは [1、2、3、4] です。長さは4です。
例 2:
- 入力: 数値 = [0,3,7,2,5,8,4,6,0,1]
- 出力: 9

6 [トピックプロンプト]

$10^5$
$10^9 <= nums[i] <= 10^9$

7つの【問題解決アイデア】

ハッシュテーブルを使用するという考え方
まず、配列内の要素をハッシュテーブルに追加します。これの目的は、重複を削除し、その後の計算を容易にすることです。
次に、ハッシュテーブル内の各要素を走査し、この要素から始まる連続配列を計算し、ハッシュテーブルをスキャンします。
この方法では、この問題を解決するのにかかる時間は $O$ $($ $n$ $)です$
最後に結果を返します

8【時間周波数】

時間計算量: $お（ん）$ 、 $n$ は受信配列の長さです
空間の複雑さ: $お（ん）$ 、 $n$ は受信配列の長さです

9 [コード実装]

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;
    }
}

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;
}

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

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;
    }
};