454.四数相加II
给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。
为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -2^28 到 2^28 - 1 之间，最终结果不会超过 2^31 - 1 。
思路：本题是使用哈希法的经典题目，而15.三数之和and18.四数之和并不合适使用哈希法，因为三数之和和四数之和这两道题目使用哈希法在不超时的情况下做到对结果去重是很困难的，很有多细节需要处理。
而这道题目是四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不用考虑有重复的四个元素相加等于0的情况，所以相对于题目18. 四数之和，题目15.三数之和，还是简单了不少！
如果本题想难度升级：就是给出一个数组（而不是四个数组），在这里找出四个元素相加等于0，答案中不可以包含重复的四元组，大家可以思考一下，后续的文章我也会讲到的。
本题解题步骤：
- 首先定义 一个unordered_map(Java语言用HashMap)，key放a和b两数之和，value 放a和b两数之和出现的次数。
- 遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中。
- 定义int变量count，用来统计 a+b+c+d = 0 出现的次数。
- 在遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。
- 最后返回统计值 count 就可以了
补充Java HashMap getOrDefault() 方法：
getOrDefault() 方法获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值。
getOrDefault() 方法的语法为：
hashmap.getOrDefault(Object key, V defaultValue)
注：hashmap 是 HashMap 类的一个对象。
参数说明：
- key - 键
- defaultValue - 当指定的key并不存在映射关系中，则返回的该默认值
返回值
返回 key 相映射的的 value，如果给定的 key 在映射关系中找不到，则返回指定的默认值。
实例：
import java.util.HashMap;
class Main {
public static void main(String[] args) {
// 创建一个 HashMap
HashMap<Integer, String> sites = new HashMap<>();
// 往 HashMap 添加一些元素
sites.put(1, "Google");
sites.put(2, "Runoob");
sites.put(3, "Taobao");
System.out.println("sites HashMap: " + sites);
// key 的映射存在于 HashMap 中
// Not Found - 如果 HashMap 中没有该 key，则返回默认值
String value1 = sites.getOrDefault(1, "Not Found");
System.out.println("Value for key 1: " + value1);
// key 的映射不存在于 HashMap 中
// Not Found - 如果 HashMap 中没有该 key，则返回默认值
String value2 = sites.getOrDefault(4, "Not Found");
System.out.println("Value for key 4: " + value2);
}
}执行结果 ：
Value for key 1: Google
Value for key 4: Not Found
注意：我们可以使用 HashMap containsKey() 方法来检查 HashMap 是否存在特定的键 key。
class Solution {
public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
int res = 0;
HashMap<Integer,Integer> map = new HashMap<>();//定义 一个HashMap，有key和value
//统计两个数组中的元素之和,同时统计出现的次数，放入map
for(int i : nums1){ //遍历A、B数组，取a、b两数之和为键key，和出现的次数为值value
for(int j : nums2){
int sum = i + j;//a、b两数之和
map.put(sum,map.getOrDefault(sum,0)+1);
//这里两层方法嵌套了一下，put的两个参数就是(key,value)
//getOrDefault(sum,0)+1,sum如果存在，也就是找的到key，返回对应的value，且出现次数再+1
//sum如果不存在，就返回默认value值 0;说明第一次出现，所以出现次数value+1
}
}
//统计剩余的两个元素之和，在map中找是否存在相加为0的情况，同时记录次数
for(int i : nums3){
for(int j : nums4){
int temp = 0 - i - j; //temp为对应条件下的a和b的和，然后去找一下是否存在
res += map.getOrDefault(temp,0);
//getOrDefault(temp,0)表示temp存在，返回对应的value，不存在则返回0
}
}
return res;
}
}- 时间复杂度: O(n^2)
- 空间复杂度: O(n^2)，最坏情况下A和B的值各不相同，相加产生的数字个数为 n^2
383. 赎金信
建议：本题 和 242.有效的字母异位词 是一个思路 ，算是拓展题
思路 ：
本题判断第一个字符串ransom能不能由第二个字符串magazines里面的字符构成，但是这里需要注意两点。
第一点“为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思” 这里说明杂志里面的字母不可重复使用。
第二点 “你可以假设两个字符串均只含有小写字母。” 说明只有小写字母，这一点很重要
暴力解法
那么第一个思路其实就是暴力枚举了，两层for循环，不断去寻找，
- 时间复杂度: O(n^2)
- 空间复杂度: O(1)
哈希解法
因为题目说只有小写字母，那可以采用空间换取时间的哈希策略，用一个长度为26的数组来记录magazine里字母出现的次数。
然后再用ransomNote去验证这个数组是否包含了ransomNote所需要的所有字母。
依然是数组在哈希法中的应用。
一些同学可能想，用数组干啥，都用map完事了，其实在本题的情况下，使用map的空间消耗要比数组大一些的，因为map要维护红黑树或者哈希表，而且还要做哈希函数，是费时的！数据量大的话就能体现出来差别了。 所以数组更加简单直接有效！
class Solution {
public boolean canConstruct(String ransomNote, String magazine) {
//第二种方法：依然使用数组在哈希法中的应用
//如果magazine短直接false
if(ransomNote.length() > magazine.length()){
return false;
}
//定义一个哈希映射数组,初始值默认0，对应26个小写英文字母
int[] record = new int[26];
//分别遍历，统计两个数组
//注：toCharArray() 方法将字符串转换为字符数组。
for(char c : magazine.toCharArray()){
record[c - 'a'] += 1;
}
for(char c : ransomNote.toCharArray()){
record[c - 'a'] -= 1;
}
//如果数组中存在负数，说明ransomNote字符串中存在magazine中没有的字符
for(int i : record){
if(i < 0){
return false;
}
}
return true;
}
}- 时间复杂度: O(n)
- 空间复杂度: O(1)
toCharArray() 方法将字符串转换为字符数组。
15. 三数之和
给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
注意： 答案中不可以包含重复的三元组。
示例：给定数组 nums = [-1, 0, 1, 2, -1, -4]，满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]
思路 ：
哈希解法
两层for循环就可以确定 a 和b 的数值了，可以使用哈希法来确定 0-(a+b) 是否在 数组里出现过，其实这个思路是正确的，但是我们有一个非常棘手的问题，就是题目中说的不可以包含重复的三元组。
把符合条件的三元组放进vector中，然后再去重，这样是非常费时的，很容易超时，也是这道题目通过率如此之低的根源所在。
去重的过程不好处理，有很多小细节，如果在面试中很难想到位。
时间复杂度可以做到O(n^2)，但还是比较费时的，因为不好做剪枝操作。
大家可以尝试使用哈希法写一写，就知道其困难的程度了。
- 时间复杂度: O(n^2)
- 空间复杂度: O(n)，额外的 set 开销
双指针
其实这道题目使用哈希法并不十分合适，因为在去重的操作中有很多细节需要注意，在面试中很难直接写出没有bug的代码。
而且使用哈希法 在使用两层for循环的时候，能做的剪枝操作很有限，虽然时间复杂度是O(n^2)，也是可以在leetcode上通过，但是程序的执行时间依然比较长 。
接下来我来介绍另一个解法：双指针法，这道题目使用双指针法 要比哈希法高效一些，那么来讲解一下具体实现的思路。
拿这个nums数组来举例，首先将数组排序，然后有一层for循环，i从下标0的地方开始，同时定一个下标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相遇为止。
时间复杂度：O(n^2)。
去重逻辑的思考
#a的去重
说到去重，其实主要考虑三个数的去重。 a, b ,c, 对应的就是 nums[i]，nums[left]，nums[right]
a 如果重复了怎么办，a是nums里遍历的元素，那么应该直接跳过去。
但这里有一个问题，是判断 nums[i] 与 nums[i + 1]是否相同，还是判断 nums[i] 与 nums[i-1] 是否相同。
有同学可能想，这不都一样吗。其实不一样！
都是和 nums[i]进行比较，是比较它的前一个，还是比较它的后一个。
如果我们的写法是 这样：
if (nums[i] == nums[i + 1]) { // 去重操作
continue;}那我们就把 三元组中出现重复元素的情况直接pass掉了。 例如{-1, -1 ,2} 这组数据，当遍历到第一个-1 的时候，判断 下一个也是-1，那这组数据就pass了。
我们要做的是 不能有重复的三元组，但三元组内的元素是可以重复的！
所以这里是有两个重复的维度。
那么应该这么写：
if (i > 0 && nums[i] == nums[i - 1]) {
continue;
}#b与c的去重:
但细想一下，这种去重其实对提升程序运行效率是没有帮助的。
拿right去重为例，即使不加这个去重逻辑，依然根据 while (right > left) 和 if (nums[i] + nums[left] + nums[right] > 0) 去完成right-- 的操作。
多加了 while (left < right && nums[right] == nums[right + 1]) right--; 这一行代码，其实就是把 需要执行的逻辑提前执行了，但并没有减少 判断的逻辑。
最直白的思考过程，就是right还是一个数一个数的减下去的，所以在哪里减的都是一样的。
所以这种去重 是可以不加的。 仅仅是 把去重的逻辑提前了而已。
但是 实际再力扣中测试发现，没有 right和left去重的话，显示时间超过了限制？！
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> result = new ArrayList<>(); //创建ArrayList集合result用来存放结果
Arrays.sort(nums); //首先对原数组进行排序操作
//找出 a + b + c = 0
//a = nums[i]; b = nums[left]; c = nums[right]
for(int i = 0; i < nums.length;i ++){
//排序之后如果第一个元素已经大于0，那么直接返回结果即可
if(nums[i] > 0){
return result;
}
if(i > 0 && nums[i] == nums[i-1]){ //去重a
continue;
}
int left = i + 1;
int right = nums.length -1;
while(right > left){ //开始遍历整数数组nums
int sum = nums[i] + nums[left] + nums[right];
if(sum > 0){
right -- ;
}else if(sum < 0){
left ++ ;
}else {
result.add(Arrays.asList(nums[i],nums[left],nums[right]));
// 去重逻辑应该放在找到一个三元组之后，对b 和 c去重,是否需要？
while (right > left && nums[right] == nums[right - 1]) right--;
while (right > left && nums[left] == nums[left + 1]) left++;
right--;
left++;
}
}
}
return result;
}
}18. 四数之和
题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。
注意：答案中不可以包含重复的四元组。
示例： 给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。 满足要求的四元组集合为： [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]
思路：
四数之和，和15.三数之和是一个思路，都是使用双指针法, 基本解法就是在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)就可以了。
15.三数之和的双指针解法是一层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(n^2)，四数之和的时间复杂度是O(n^3) 。
那么一样的道理，五数之和、六数之和等等都采用这种解法。
对于15.三数之和 的双指针法就是将原本暴力O(n^3)的解法，降为O(n^2)的解法，四数之和的双指针解法就是将原本暴力O(n^4)的解法，降为O(n^3)的解法。
之前我们讲过哈希表的经典题目：454.四数相加 || 相对于本题简单很多，因为本题是要求在一个集合中找出四个数相加等于target，同时四元组不能重复。
而454.四数相加|| 是四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不用考虑有重复的四个元素相加等于0的情况，所以相对于本题还是简单了不少！
我们来回顾一下，几道题目使用了双指针法。
双指针法将时间复杂度：O(n^2)的解法优化为 O(n)的解法。也就是降一个数量级，题目如下：
27.移除元素、 15.三数之和、18、四数之和
链表相关双指针题目：
206.反转链表、 19.删除链表的倒数第N个节点、 面试题02、07链表相交（160）、
142.环形链表||
双指针法在字符串题目中还有很多应用，后面还会介绍到。
class Solution {
public List<List<Integer>> fourSum(int[] nums, int target) {
List<List<Integer>> result = new ArrayList<>();
Arrays.sort(nums);
for (int i = 0; i < nums.length; i++) {
// nums[i] > target 直接返回, 剪枝操作
if (nums[i] > 0 && nums[i] > target) {
return result;
}
if (i > 0 && nums[i - 1] == nums[i]) { // 对nums[i]去重
continue;
}
for (int j = i + 1; j < nums.length; j++) {
if (j > i + 1 && nums[j - 1] == nums[j]) { // 对nums[j]去重
continue;
}
int left = j + 1;
int right = nums.length - 1;
while (right > left) {
// nums[k] + nums[i] + nums[left] + nums[right] > target int会溢出
long sum = (long) nums[i] + nums[j] + nums[left] + nums[right];
if (sum > target) {
right--;
} else if (sum < target) {
left++;
} else {
result.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
// 对nums[left]和nums[right]去重
while (right > left && nums[right] == nums[right - 1]) right--;
while (right > left && nums[left] == nums[left + 1]) left++;
left++;
right--;
}
}
}
}
return result;
}
}
