力扣100热题[哈希]：最长连续序列

原创已于 2024-03-22 10:39:24 修改 · 469 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #哈希算法 #算法

于 2024-03-22 10:27:13 首次发布

文章介绍了两种解决LeetCode最长连续序列问题的方法，一种是暴力解法结合二分法思想，另一种是直接遍历并检查相邻元素连续性。作者探讨了如何在处理包含负数和控制边界值的情况下优化算法性能。

原题：128. 最长连续序列

题解：

官方题解：. - 力扣（LeetCode）题解，最长连续序列：哈希表

官方解题思路是先去重，然后判断模板长度的数值是否存在，存在就刷新，最终找到最大值。

这里我自己研究了下，实际也是暴力解法。纯暴力解法会超时，这里利用了二分法查找的理念

首先去重
然后排序
固定begin，然后找最大的end，返回 $max=end-begin+1$ 使用二分法理念进行查找
依次遍历，在 $end-begin<curmax$ 已经找到的最大值，返回 $curmax +1$

自己尝试了下，部分通过，有些边界值不太好控制，而且输入里面有负数，也不太好计算。

还有一种解题方法，就是在官方题解上做个变化，

首先去重
然后排序
依次遍历，找到满足 $nums[i + 1] = nums[i] + 1$ 的最长子数组，返回其长度。

代码：

func longestConsecutive(nums []int) int {
    // 如果数组为空，或者只有一个元素，直接返回数组长度
	if len(nums) <= 1 {
		return len(nums)
	}

	// 去重
	numSet := map[int]bool{}
	for _, num := range nums {
		numSet[num] = true
	}

	// 排序
	numTemp := make([]int, 0)
	for num := range numSet {
		numTemp = append(numTemp, num)
	}
	sort.Ints(numTemp)
	// fmt.Printf("numTemp %v\n", numTemp)

	// 暴力解法
	longestStreak := 0
	for begin := range numTemp {
		// 当剩余的个数，小于当前最大长度，则后面不可能有满足条件的更大的值，返回
		if begin+longestStreak > len(numTemp) {
			return longestStreak + 1
		}
		temp := BinarySearchMatch(numTemp, begin, longestStreak)
		if longestStreak < temp {
			longestStreak = temp
		}
	}
	return longestStreak + 1
}

func BinarySearchMatch(numTemp []int, begin, cur int) int {
	longestStreak := cur
	// 当前最大可用差值
	curMaxDiff := len(numTemp) - begin - 1
	// 使用二分法的理念，查询满足条件的数据
	for end := len(numTemp) - 1; end > begin; {
		// fmt.Printf("begin %v, end %v, curMaxDiff %v\n", begin, end, curMaxDiff)
		// 索引差值超过最大值，返回，end超过数组范围，返回
		if curMaxDiff >= len(numTemp) || end >= len(numTemp) {
			break
		}
		// 差值为0时，有可能会遗漏一个，判断end的下一个是否满足条件
		if curMaxDiff == 0 {
			if end < len(numTemp)-1 && numTemp[end+1]-numTemp[begin] == end+1-begin {
				longestStreak = end + 1 - begin
			}
            
			if end > begin && numTemp[end-1]-numTemp[begin] == end-1-begin {
				longestStreak = end - 1 - begin
			}

            if end > begin && numTemp[end]-numTemp[begin] == end-begin {
				longestStreak = end - begin
			}
			break
		}
		// 数值差值
		valDiff := numTemp[end] - numTemp[begin]
		// 索引差值
		indexDiff := end - begin

		// 二分法找到合适的索引end
		// 索引差值 < 数值差值，数值太大了，中间有不连续的，往前移动curMaxDiff/2
		if valDiff > indexDiff && indexDiff != 0 {
			curMaxDiff = curMaxDiff / 2
			end = end - curMaxDiff
			continue
		}

		// 索引差值 > 数值差值，这种不可能存在，因为已经去重了
		// 索引差值 = 数值差值，后面可能还有满足条件的，继续找
		if valDiff == indexDiff {
			// 刷新最大值
			if longestStreak > valDiff {
				break
			}

			longestStreak = valDiff
			// end后移curMaxDiff/2
			curMaxDiff = curMaxDiff / 2
			end = end + curMaxDiff
			continue
		}
	}

	return longestStreak
}

第二种方法

func longestConsecutive(nums []int) int {
    // 如果数组为空，或者只有一个元素，直接返回数组长度
	if len(nums) <= 1 {
		return len(nums)
	}

	// 去重
	numSet := map[int]bool{}
	for _, num := range nums {
		numSet[num] = true
	}

	// 排序
	numTemp := make([]int, 0)
	for num := range numSet {
		numTemp = append(numTemp, num)
	}
	sort.Ints(numTemp)
	//fmt.Printf("numTemp %v\n", numTemp)

	// 暴力解法
	longestStreak := 0
	for num := range numTemp {
		if num < len(numTemp)-1 && numTemp[num]+1 == numTemp[num+1] {
			currentNum := num
			currentStreak := 1
			for currentNum < len(numTemp)-1 && numTemp[currentNum]+1 == numTemp[currentNum+1] {
				currentNum++
				currentStreak++
			}
			if longestStreak < currentStreak {
				longestStreak = currentStreak
			}
		}
	}
	return longestStreak
}