具体思想：

具体思路分两种，一种是map哈希，一种是并查集；

使用标准数组hash会超时；

1.map哈希：

map保存是否出现，但是有一个遍历的trick；

如果map[i]出现，则枚举map[i+1]；

如果用该方法，则map[i-1]必定已经枚举过，所以必定只需要枚举map[i-1]不存在的元素即可；

2.并查集：

连续相邻的构成一个并查集，这里注意一下示例代码的边查边遍历；

具体代码：

1.map哈希：

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        map<int,int>mp;
        for(auto ele:nums){
            mp[ele]=1;
        }
        int cnt=0;
        for(int i=0;i<nums.size();i++){
            if(mp.find(nums[i]-1)==mp.end()){
                int c=0;
                int num=nums[i];
                while(mp.find(num)!=mp.end()){
                    c++;
                    num++;
                }
                cnt=max(c,cnt);
            }
        }
        return cnt;
    }
};

2.并查集：

class Solution {
public:
    // cnt用于记录当前集合的元素个数
    unordered_map<int,int> uf, cnt;

    int find(int i){
        return i == uf[i] ? i: uf[i] = find(uf[i]);
    }

    int merge(int x, int y){
        x = find(x); y = find(y);
        if(x == y) return cnt[x];
        uf[y] = x;
        //更新合并之后的连通分量的元素个数
        cnt[x] += cnt[y];
        return cnt[x];
    }

    int longestConsecutive(vector<int>& nums) {
        if(nums.size() == 0) 
            return 0;
        for(int i: nums) uf[i] = i, cnt[i] = 1;
        int ans = 1;
        for(int i: nums){
            if(i != INT_MAX && uf.count(i+1)) ans = max(ans, merge(i, i+1));
        }
        return ans;
    }
};