渐入佳境，剖析 LeetCode #128 最长连续序列的妙招！

IOS

2023-12-09 02:21:41

征服连续序列难题：LeetCode #128 解密

在算法学习的殿堂中，LeetCode 犹如一座屹立的丰碑，考验着算法爱好者的智慧和韧性。其中，#128 最长连续序列问题更是跻身 Top 100 高频题之列，成为算法高手必经的磨砺之路。

问题剖析：连续序列的奥义

给你一个无序整数数组 nums，找出最长的连续正整数序列的长度。例如：

对于 nums = [100, 4, 200, 1, 3, 2]，最长的连续正整数序列是 [1, 2, 3]，因此返回 3。
对于 nums = [1, 2, 0, 1]，最长的连续正整数序列是 [1, 2]，因此返回 2。

解法一：哈希表的巧妙应用

哈希表是一种强大的数据结构，可以快速查找和插入元素。在这个解法中，我们将每个整数 nums[i] 作为键，其对应的连续序列长度作为值。

算法步骤：

初始化一个哈希表 map。
遍历数组 nums，对于每个元素 nums[i]：
- 如果 map 中包含键 nums[i]，则跳过该元素。
- 否则：
  - 向前查找比 nums[i] 大的连续整数，计算长度 left。
  - 向后查找比 nums[i] 小的连续整数，计算长度 right。
  - 将 map[nums[i]] 设置为 left + right + 1。
在哈希表中查找具有最大值的键，并返回其对应的值。

解法二：并查集的优雅合并

并查集是一种高效的算法，用于管理不交叠集合的合并和查找操作。在这个解法中，我们将每个整数 nums[i] 视为一个集合的代表元素。

算法步骤：

初始化一个并查集 uf。
遍历数组 nums，对于每个元素 nums[i]：
- 如果 uf 中不存在包含 nums[i] 的集合：
  - 创建一个新的集合，其代表元素为 nums[i]。
- 否则：
  - 找到包含 nums[i] 的集合的代表元素 parent。
  - 如果 parent + 1 在 uf 中存在，则合并包含 nums[i] 和 parent + 1 的集合。
返回 uf 中所有集合中元素最多的集合的元素数量。

代码示例：Swift 中的优雅实现

哈希表解法：

func longestConsecutive(_ nums: [Int]) -> Int {
    var map = [Int: Int]()
    var maxLen = 0

    for num in nums {
        guard map[num] == nil else {
            continue
        }
        
        let left = map[num - 1] ?? 0
        let right = map[num + 1] ?? 0
        
        let newLen = left + right + 1
        maxLen = max(maxLen, newLen)
        
        map[num] = newLen
        map[num - left] = newLen
        map[num + right] = newLen
    }
    
    return maxLen
}

并查集解法：

class UnionFind {
    private var parent: [Int]
    private var size: [Int]

    init(_ n: Int) {
        parent = Array(repeating: 0, count: n)
        size = Array(repeating: 1, count: n)
        for i in 0..<n {
            parent[i] = i
        }
    }
    
    func find(_ x: Int) -> Int {
        if parent[x] != x {
            parent[x] = find(parent[x])
        }
        return parent[x]
    }
    
    func union(_ x: Int, _ y: Int) {
        let rootX = find(x)
        let rootY = find(y)
        if rootX != rootY {
            if size[rootX] > size[rootY] {
                parent[rootY] = rootX
                size[rootX] += size[rootY]
            } else {
                parent[rootX] = rootY
                size[rootY] += size[rootX]
            }
        }
    }
}

func longestConsecutive(_ nums: [Int]) -> Int {
    let uf = UnionFind(nums.count)
    var numToIndex = [Int: Int]()
    
    for (i, num) in nums.enumerated() {
        numToIndex[num] = i
    }
    
    for num in nums {
        if let index = numToIndex[num - 1] {
            uf.union(i, index)
        }
        
        if let index = numToIndex[num + 1] {
            uf.union(i, index)
        }
    }
    
    var maxSize = 0
    for i in 0..<nums.count {
        maxSize = max(maxSize, uf.size[uf.find(i)])
    }
    
    return maxSize
}