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

454.四数相加II

建议：本题是 使用map 巧妙解决的问题，好好体会一下 哈希法 如何提高程序执行效率，降低时间复杂度，当然使用哈希法 会提高空间复杂度，但一般来说我们都是舍空间 换时间， 工业开发也是这样。

本题解题步骤：

首先定义 一个unordered_map，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 就可以了

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
         Map<Integer, Integer> map = new HashMap<>();
         int result=0;
         for (int i:nums1){
            for(int j:nums2){
                int sum=i+j;
                //hashmap.getOrDefault(Object key, V defaultValue)获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值
                map.put(sum,map.getOrDefault(sum,0)+1);
            }
         }
        for (int a:nums3){
            for(int b:nums4){
                result+=map.getOrDefault(0-a-b,0);
            }
        }
        return result;
         }
}

383. 赎金信

建议：本题 和 242.有效的字母异位词 是一个思路 ，算是拓展题

题目链接/文章讲解：https://programmercarl.com/0383.%E8%B5%8E%E9%87%91%E4%BF%A1.html

15. 三数之和

建议：本题虽然和 两数之和 很像，也能用哈希法，但用哈希法会很麻烦，双指针法才是正解，可以先看视频理解一下 双指针法的思路，文章中讲解的，没问题 哈希法很麻烦。
三数之和的时间复杂度是O(n^2)

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result=new ArrayList<>();
        // int [] nums2={};
        Arrays.sort(nums);//从小到大排序
        for(int i=0;i<nums.length;i++){
            if(nums[i]>0){//因为已经排序了，如果连i都大于0，后面那两个肯定大于0，三元组肯定大于0
                return result;
            }
            if(i>0&&nums[i]==nums[i-1]){//去重答案中第一位元素
                continue;
            }
            int left=i+1;
            int right=nums.length-1;//left,right分别是答案中第二、三位元素
            while(left<right){
                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]));
                    while(right>left&&nums[left]==nums[left+1]){left++;}//第二个元素去重
                    while(right>left&&nums[right]==nums[right-1]){right--;}//第三个元素去重
                    right--;
                    left++;
                }
            }
        }
        return result;
    }
}

18. 四数之和

建议： 要比较一下，本题和 454.四数相加II 的区别，为什么 454.四数相加II 会简单很多，这个想明白了，对本题理解就深刻了。 本题 思路整体和 三数之和一样的，都是双指针，但写的时候 有很多小细节，需要注意，建议先看视频。
四数之和的双指针解法是两层for循环nums[k] + nums[i]为确定值，依然是循环内有left和right下标作为双指针，找出nums[k] + nums[i] + nums[left] + nums[right] == target的情况，三数之和的时间复杂度是O(n^{2)，四数之和的时间复杂度是O(n}3) 。

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

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++){
            if(nums[i]>0&& nums[i]>target){return result;}  // nums[i] > target 直接返回, 剪枝操作
            if(i>0&&nums[i-1]==nums[i]){continue;} // 对nums[i]去重
            for (int j=i+1;j<nums.length;j++){
                if(j>i+1&&nums[j-1]==nums[j]){continue;}// 对nums[j]去重
                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]));
                        while (right>left && nums[left]==nums[left+1]){left++;}//对nums[left]\nums[right]去重
                        while (right>left && nums[right]==nums[right-1]){right--;}
                        right--;
                        left++;
                    }
                }
            }  
         }return result;

    }
}