代码随想录 day07 第三章哈希表part02

厦门奥特曼

已于 2024-02-29 18:13:39 修改

阅读量632

点赞数 13

分类专栏：代码随想录文章标签：散列表数据结构

于 2024-02-28 22:21:43 首次发布

本文链接：https://blog.csdn.net/weixin_60315213/article/details/136357826

版权

代码随想录专栏收录该内容

39 篇文章 0 订阅

订阅专栏

今日任务

● 454.四数相加II

● 383. 赎金信

● 15. 三数之和

● 18. 四数之和

● 总结

1. 四数相加II

关联 leetcode 454.四数相加II

思路
- 目标是找到满足累加和的所有组合
- 每个数组里面挑选一个数满足累加 == 0 就行
- 两两配对，求和
- 因为都是单向循环，所以能保证在每个数组内都只取一个数
- Golang: map特性默认零值,这题不用判断key是否出现过

题解

使用哈希表 map形式实现

func fourSumCount(nums1 []int, nums2 []int, nums3 []int, nums4 []int) int {
	//满足要求的 a+b+c+d = 0 的次数
	ret := 0

	// 存放数组1,2的累加和与出现次数
	// key: 所取两个元素之和, val: 出现的次数
	// Golang: map特性 默认零值,这题不用判断key是否出现过
	sumMap := make(map[int]int)
	for i := range nums1 {
		for j := range nums2 {
			idx := nums1[i] + nums2[j]
			sumMap[idx]++
		}
	}
	// 遍历数组3, 4求和
	// 从已遍历过的map中找到满足条件的 数组1,2 的和
	// 不需要移除map元素
	for i := range nums3 {
		for j := range nums4 {
			idx := 0 - (nums3[i] + nums4[j])
			ret += sumMap[idx]
		}
	}
	return ret
}

2. 赎金信

关联 leetcode 383. 赎金信

思路：
- magazine里字母出现的次数是否包含了ransomNote所需要的所有字母。
- magazine里面的每个字母只能用一次
- map可以解决但空间消耗大于数组

题解

Map

func canConstruct(ransomNote string, magazine string) bool {
	alphaMap := make(map[rune]int)

	for _, chart := range magazine {
		alphaMap[chart]++
	}
	for _, chart := range ransomNote {
		alphaMap[chart]--
		if alphaMap[chart] < 0 {
			return false
		}
	}
	return true
}

Array

func canConstruct(ransomNote string, magazine string) bool {
	alphaArray := make([]int, 26)

	for _, chart := range magazine {
		alphaArray[chart-'a']++
	}
	for _, chart := range ransomNote {
		alphaArray[chart-'a']--
		if alphaArray[chart-'a'] < 0 {
			return false
		}
	}
	return true
}

3. 三数之和

关联 leetcode 15. 三数之和

这道题哈希表反而比较麻烦，建议用双指针解决
感觉本题的描述不太清楚重新按照自己的语言组织一下
- 要求返回的数组内三个数字之和为0
- 三个数字在原数组内的下标不同
- 每三个数构成一个集合的元素
  - 每一组三个数仅能出现一次
    - 所以也就出现了剪枝的需求

题解

func threeSum(nums []int) [][]int {
	rets := make([][]int, 0)
	//1. 先对原数组排序
	slices.Sort(nums)

	for i := 0; i < len(nums)-2; i++ {
		if nums[i] > 0 {
			//排序后的第一个元素都大于0,则后续所有元素都>0; 直接返回就好
			return rets
		}

		// 对元素a去重, 前面已经算过该元素了
		// 当前数组: -1,-1,0,1,1
		// i 在 左二的 -1, 就是之前已经计算过了
		if i > 0 && nums[i] == nums[i-1] {
			continue
		}
		//左右双指针, 往中间移动
		l := i + 1         // 左边元素
		r := len(nums) - 1 //右边元素, 当前数组最大元素

		for r > l {
			if nums[i]+nums[l]+nums[r] > 0 {
				// 和 > 0, 缩小右值
				r--
			} else if nums[i]+nums[l]+nums[r] < 0 {
				// 和 < 0, 增大左值
				l++
			} else {
				// 和为0,记录结果
				rets = append(rets, []int{nums[i], nums[l], nums[r]})
				//右指针剪枝
				for r > l && nums[r] == nums[r-1] {
					//解释:
					//例如: 此时满足的元素 -1
					//当前数组: -1,-1,0,1,1
					//现在右指针在最右边的1, 则从右二的1也不能出现在结果里面,因为数值重复了
					r-- // 移除重复右元素
				}
				//左指针同理
				for r > l && nums[l] == nums[l+1] {
					l++ // 移除重复左元素
				}

				// 找到答案时，双指针同时收缩
				r--
				l++

			}
		}
	}

	return rets
}

4. 四数之和

关联 leetcode 18. 四数之和

类似三数之和
- 在三数之和外面再加一个指针
- 最外层两个指针【紧挨着】，一同从头向尾移动【保证了两个 index 不同的数】
- 同三数之和一样继续做剪枝去重操作
target的要求，target不同于三数之和可以为负数
结果要求 [][]int{}
- 里面的 []int{nums[k],nums[i],nums[l],nums[r]}
  - k, i, l, r 互不相等
  - nums[k],nums[i],nums[l],nums[r] 彼此间可以相等

题解

func fourSum(nums []int, target int) [][]int {
	var rets [][]int
	//1. 依旧先对数组排序
	slices.Sort(nums)
	for k := range nums {
		//剪枝
		if nums[k] > target && nums[k] >= 0 {
			break
		}
		//去重
		if k > 0 && nums[k] == nums[k-1] {
			continue
		}
		for i := k + 1; i < len(nums)-2; i++ {
			//剪枝
			if nums[k]+nums[i] > target && nums[k]+nums[i] >= 0 {
				break
			}
			//去重
			if i > k+1 && nums[i] == nums[i-1] {
				continue
			}
			//	通三数之和的双指针
			l, r := i+1, len(nums)-1
			for r > l {
				if nums[k]+nums[i]+nums[l]+nums[r] > target {
					r--
				} else if nums[k]+nums[i]+nums[l]+nums[r] < target {
					l++
				} else {
					rets = append(rets, []int{nums[k], nums[i], nums[l], nums[r]})
					//	去重
					for l < r && nums[l] == nums[l+1] {
						l++
					}
					for l < r && nums[r] == nums[r-1] {
						r--
					}
					//	收缩左右指针
					l++
					r--
				}
			}
		}
	}
	return rets
}