代码随想录算法训练营第7天 | 454. 四数相加 II ，383. 赎金信，15. 三数之和，18. 四数之和

哈希知识基础

文章链接：https://programmercarl.com/%E5%93%88%E5%B8%8C%E8%A1%A8%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html#%E5%93%88%E5%B8%8C%E8%A1%A8

454. 四数相加 II

题目链接：https://leetcode.cn/problems/4sum-ii/description/

思路:哈希法

这道题目是四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不用考虑有重复的四个元素相加等于0的情况。
他这里不用考虑重复的情况，同时也只要求多少个，不用求下标，用哈希法很快。
我们的思路就是对数组1和数组2的所有可能的相加结果，加到hashmap里，因为map里可以存key跟value，value就是出现的次数。因为假如出现了3次的话，后面加是要3次的。然后再把num3和num4所有可能的相加结果挨个的遍历一遍，再通过map去查找有没有对应的value，如果有的话就直接相加。

class Solution {public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {Map<Integer,Integer>map = new HashMap<>();for(int i:nums1){for(int j:nums2){int sum = i+j;map.put(sum,map.getOrDefault(sum,0)+1);}}int result = 0;for(int i:nums3){for(int j:nums4){result += map.getOrDefault(0-i-j,0);}}return result;}
}

时间复杂度 O(n^2)
空间复杂度 O(n^2)

383. 赎金信

题目连接：https://leetcode.cn/problems/ransom-note/description/

解法：哈希法

这题很简单，用一个简单的数组做哈希映射就可以解决。

class Solution {public boolean canConstruct(String ransomNote, String magazine) {int[]arr = new int[26];for(char ch:magazine.toCharArray()){arr[ch-'a'] += 1;}for(char ch:ransomNote.toCharArray()){arr[ch-'a'] -= 1;}for(int i:arr){if(i<0)return false;}return true;}
}

时间复杂度 O(n)
空间复杂度 O(1)

15. 三数之和

题目连接：https://leetcode.cn/problems/3sum/description/

解法：双指针法

以nums数组来举例，首先将数组排序，（排序可以方便我们之后比较是否有重复的数值）然后有一层for循环，i从下标0的地方开始，for循环中 i指向的是第一个数字，同时定义一个下标left 定义在i+1的位置上，定义下标right 在数组结尾的位置上。

依然还是在数组中找到 abc 使得a + b +c =0，我们这里相当于 a = nums[i]，b = nums[left]，c = nums[right]。

接下来如何移动left 和right呢，如果nums[i] + nums[left] + nums[right] > 0 就说明此时三数之和大了，因为数组是排序后了，所以right下标就应该向左移动，这样才能让三数之和小一些。

如果 nums[i] + nums[left] + nums[right] < 0 说明此时三数之和小了，left 就向右移动，才能让三数之和大一些，直到left与right相遇为止。

同时，a，b，c的去重这里也是需要注意的地方
a的去重，不能是nums[i] == nums[i+1] ，这样1,1,2 这样的情况，这组数据就直接被pass掉了，我们正确的理解应该是出现和之前相同的数字时再去重。（记得加上i>0 ，否则index可能会报错）
然后b跟c的去重也是，找到了我们要求的解时，也要在他的附近看看是否还有同样的值，给他去重了

class Solution {public List<List<Integer>> threeSum(int[] nums) {List<List<Integer>>ans = new ArrayList<>();Arrays.sort(nums);for(int i=0;i<nums.length;i++){int left = i+1;int right = nums.length - 1;// 剪枝,如果第一个数就大于0，说明怎么组合都不可能满足条件了if(nums[i]>0)return ans;// 对a去重if(i>0 && nums[i]==nums[i-1])continue;// 双指针法while(left < right){int sum = nums[i] + nums[left] + nums[right];if(sum>0){right --;} else if(sum<0)left++;else{// 找到一个解ans.add(Arrays.asList(nums[i],nums[left],nums[right]));// 找到后不等于说其他情况不存在了，比如0+8,后面还有3+5// 对相同的b跟c要进行去重// !! right>left也要加上，防止后面的值都是一样的，然后left报了index错误while(right>left && nums[left]==nums[left+1]) left++;while(right>left && nums[right]==nums[right-1])  right--;left++;right--;}}}return ans;}
}

时间复杂度：O(n^2)

解法2：哈希法（不推荐用）

两层for循环就可以确定 a 和b 的数值了，可以使用哈希法来确定 0-(a+b) 是否在数组里出现过，其实这个思路是正确的，但是我们有一个非常棘手的问题，就是题目中说的不可以包含重复的三元组。
去重的过程不好处理，有很多小细节，很难想到位。

时间复杂度可以做到O(n^2)，但还是比较费时的，因为不好做剪枝操作。

class Solution {public List<List<Integer>> threeSum(int[] nums) {Arrays.sort(nums);List<List<Integer>>ans = new ArrayList<>();for(int i=0;i<nums.length;i++){if(nums[i]>0)   // 剪枝break;// 三元组a去重if(i>0 && nums[i] == nums[i-1])continue;Set<Integer>set = new HashSet<>();for(int j=i+1; j<nums.length;j++){// 三元组b去重// 检查当前的b和前一个b是否相同，如果相同，则跳过当前的b// 如果只写nums[j]=nums[j-1]，就会出现把a也算进去的情况 [-1,-1,0,2...]// if(nums[j]==nums[j-1])//     continue;// j>2 也不行，j一定要在i的后面三位开始判断 // [0,0,0],[0,0,0,1],[0,0,0,0]if(j>i+2 && nums[j]==nums[j-1] && nums[j-1]==nums[j-2])continue;int c = 0-(nums[i]+nums[j]);if(set.contains(c)){ans.add(Arrays.asList(nums[i],nums[j],c));set.remove(c);}elseset.add(nums[j]);}}return ans;}
}

18. 四数之和

题目连接：https://leetcode.cn/problems/4sum/

解法：双指针法

和上一题十分的类似，只不过从3个数变成了4个数之和，和15.三数之和是一个思路，都是使用双指针法, 基本解法就是在上一题基础上再套一层for循环。
但是有一些细节需要注意，例如：不要判断nums[k] > target 就返回了，三数之和可以通过 nums[i] > 0 就返回了，因为 0 已经是确定的数了，四数之和这道题目 target是任意值。比如：数组是[-4, -3, -2, -1]，target是-10，不能因为-4 > -10而跳过。但是我们依旧可以去做剪枝，逻辑变成nums[i] > target && (nums[i] >=0 || target >= 0)就可以了。

三数之和的双指针解法是一层for循环num[i]为确定值，然后循环内有left和right下标作为双指针，找到nums[i] + nums[left] + nums[right] == 0。

四数之和的双指针解法是两层for循环nums[k] + nums[i]为确定值，依然是循环内有left和right下标作为双指针，找出nums[k] + nums[i] + nums[left] + nums[right] == target的情况，三数之和的时间复杂度是O(n2)，四数之和的时间复杂度是O(n^3) 。

那么一样的道理，五数之和、六数之和等等都采用这种解法。

对于15.三数之和 (opens new window)双指针法就是将原本暴力O(n3)的解法，降为O(n2)的解法，四数之和的双指针解法就是将原本暴力O(n4)的解法，降为O(n^3)的解法。

同时，注意一下这里的四个数相加可能会超过int范围，最后结果转成long，防止爆了。

class Solution {public List<List<Integer>> fourSum(int[] nums, int target) {List<List<Integer>>ans = new ArrayList<>();Arrays.sort(nums);for(int i=0;i<nums.length;i++){// 可能有负数的话，就要加上nums[i]>0if(nums[i] >0 && nums[i]>target)break;if(i>0 && nums[i]==nums[i-1])continue;for(int j=i+1;j<nums.length;j++){// 对b去重 if(j>i+1 && nums[j]==nums[j-1])continue;int left = j+1;int right = nums.length-1;while(left < right){// 相加可能会溢出long sum = (long)nums[i] + nums[j] + nums[left] + nums[right];if(sum>target)right --;else if(sum<target)left++;else{ans.add(Arrays.asList(nums[i],nums[j],nums[left],nums[right]));while(left < right && nums[left] == nums[left+1])   left++;while(left < right && nums[right] == nums[right-1]) right--;left++;right--;}}}}return ans;}
}