Cacher is the code snippet organizer for pro developers

public class Solution {
        public int longestConsecutive(int[] nums) {
            UF uf = new UF(nums.length);
            Map<Integer,Integer> map = new HashMap<Integer,Integer>(); // <value,index>
            for(int i=0; i<nums.length; i++){
                if(map.containsKey(nums[i])){
                    continue;
                }
                map.put(nums[i],i);
                if(map.containsKey(nums[i]+1)){
                    uf.union(i,map.get(nums[i]+1));
                }
                if(map.containsKey(nums[i]-1)){
                    uf.union(i,map.get(nums[i]-1));
                }
            }
            return uf.maxUnion();
        }
    }
    
    class UF{
        private int[] list;
        public UF(int n){
            list = new int[n];
            for(int i=0; i<n; i++){
                list[i] = i;
            }
        }
        
        private int root(int i){
            while(i!=list[i]){
                list[i] = list[list[i]];
                i = list[i];
            }
            return i;
        }
        
        public boolean connected(int i, int j){
            return root(i) == root(j);
        }
        
        public void union(int p, int q){
          int i = root(p);
          int j = root(q);
          list[i] = j;
        }
        
        // returns the maxium size of union
        public int maxUnion(){ // O(n)
            int[] count = new int[list.length];
            int max = 0;
            for(int i=0; i<list.length; i++){
                count[root(i)] ++;
                max = Math.max(max, count[root(i)]);
            }
            return max;
        }
    }

class UnionFind
{
private:
    unordered_map<int, int> father;
    unordered_map<int, int> ssize;
    
public:
    int find(int x)
    {
        int parent = x;
        while(parent != father[parent]) parent = father[parent];
        int bigdaddy = parent;
        
        while(x != father[x])
        {
            int tmp = father[x];
            father[x] = bigdaddy;
            x = tmp;
        }
        return bigdaddy;
    }
    
    void union_(int a, int b)
    {
        int fa = find(a);
        int fb = find(b);
        if (fa != fb)
        {
            father[fa] = fb;
            ssize[fa] = ssize[fb] = ssize[fa] + ssize[fb];
        }
    }
    
    UnionFind(vector<int> &nums)
    {
        for (int i = 0; i < nums.size(); i++)
        {
            father[nums[i]] = nums[i];
            ssize[nums[i]] = 1;
        }
    }
    
    int getmaxsize()
    {
        int result = 0;
        for (auto it : ssize) result = max(result, it.second);
        return result;
    }

};

class Solution
{
public:
    int longestConsecutive(vector<int>& nums)
    {
        UnionFind uf = UnionFind(nums);
        unordered_set<int> s;
        for (int i = 0; i < nums.size(); i++) s.insert(nums[i]);
        
        for (int i = 0; i < nums.size(); i++)
        {
            if (s.count(nums[i] - 1)) uf.union_(nums[i], nums[i] - 1);
            if (s.count(nums[i] + 1)) uf.union_(nums[i] + 1, nums[i]);
        }
        return uf.getmaxsize();
    }
};

public class Solution {
public int longestConsecutive(int[] nums) {
    if(nums == null || nums.length == 0) return 0;
    
    Set<Integer> set = new HashSet<Integer>();
    
    for(int num: nums) set.add(num);
    int max = 1;
    for(int num: nums) {
        if(set.remove(num)) {//num hasn't been visited
            int val = num;
            int sum = 1;
            while(set.remove(val-1)) val--;
            sum += num - val;
            
            val = num;
            while(set.remove(val+1)) val++;
            sum += val - num;
            
            max = Math.max(max, sum);
        }
    }
    return max;
}
}

public class Solution {
    public int longestConsecutive(int[] nums) {
        int res = 0;
        if (nums == null || nums.length == 0) return res;
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (int num : nums) {
            if(!map.containsKey(num)) {
                int left = map.containsKey(num - 1) ? map.get(num - 1) : 0;
                int right = map.containsKey(num + 1) ? map.get(num + 1) : 0;
                int sum = left + right + 1;
                map.put(num, sum);
                res = Math.max(res, sum);
                map.put(num - left, sum);
                map.put(num + right, sum);
            }
        }
        return res;
    }
}