R7-哈希篇

思路：sort一下先

然后使用双指针遍历计数，同时从数组头开始。

按照题目的意思，相同元素只能取一个，所以可以用set

class Solution:
    def longestConsecutive(self, nums: List[int]) -> int:
        if len(nums)<=1:
            return len(nums)
        nums.sort()
        nums1=set(nums)
        n=len(nums1)
        mx=1
        for i in nums1:
            if i-1 not in nums1:
                cur=i
                mx1=1
                while cur+1 in nums1:
                     mx1+=1
                     cur+=1
                mx=max(mx,mx1)
        return mx

 和之前的解法不一样

class Solution:
    def longestConsecutive(self, nums: List[int]) -> int:
        #相同元素没有意义，可以舍弃
        nums=set(nums)
        ans=0

        #并查集
        #值为离散的，使用字典
        #准备用做parent字典
        fa={num:num for num in nums}
        #对于每个数字来说，以它开始的最长连续初始都为1
        size={num:1 for num in nums}

        def find(x):
            if fa[x]!=x:
                fa[x]=find(fa[x])
            return fa[x]
        
        def union(f,to):
            f=find(f)
            to=find(to)
            if f!=to:
                fa[f]=to
                size[to]+=size[f]

        #遍历数组，满足union时，取max
        for num in nums:
            if num+1 in fa:
                union(num,num+1)
        #size.values()当size是字典是能取所有的值出来
        if size:
            ans=max(size.values())
        return ans

还优化了