海智算法训练营第六天 | 第三章 哈希表part02 | 1两数之和 454四数相加II 15. 三数之和 18四数之和

学习目标：

•  1. 两数之和   
•  454.四数相加II 
•  15. 三数之和 
•  18. 四数之和 
•  总结  

1.Map集合存储下标

 题目：两数之和

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer,Integer> map = new HashMap<>();
        int[] res = new int[2];
        for(int i =0;i<nums.length;i++){
            int temp = target-nums[i];
            if(map.containsKey(temp)){
                res[0] = i;
                res[1] = map.get(temp);
                break;
            }
            map.put(nums[i],i);
        }
        return res;
    }
}

这道题用map集合主要是因为有两个原因：1.有两个值需要判断，这时候map集合天然的优势，key—value键值对，key存储元素的值，value存储元素的下标。 2.数组长度不确定，而用哈希表数组的解法可能会浪费内存空间。

解法：先将数组的元素值和下标通过循环逐一加入map集合中，同时在加入时判断map集合内是否有与其配对的target，如果有，就结束循环，并返回两个值的下标，map集合的下标就用map.get(key)方法求得。

2.利用Map存储出现次数

题目：四数相加

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        Map<Integer,Integer> map = new HashMap<>();
        for(int a : nums1){
            for(int b : nums2){
                map.put(a+b,map.getOrDefault(a+b,0)+1);
            }
        }
        int res = 0;
        for(int c : nums3){
            for(int d : nums4){
                if(map.containsKey(0-c-d)){
                    res += map.get(0-c-d);
                }
            }
        }
        return res;
    }
}

这道题因为仅仅只有四个数组，所以解法较为简单，可以将四个数组分成两个部分循环，这样的话遍历所有时间复杂度就会从O(n^4)  >> O(n^2)，可以先将前两个数组的值先加起来并用map集合存储他的出现次数，然后再遍历后两个数组的值加起来如果和前两个数组相加的值是相反数，那么就是一对res，res+=前两个数组的值的出现次数。

3. 利用双指针解三数之和

题目：三数之和

这题如果使用map集合会非常麻烦，因为有去重的操作，这里有三个数需要去重，所以不好用map集合，这里可以运用一个简便方法——双指针，思路是先排序，让i指向第一个数，left指向第二个数，right指向最后一个数，如果三个数的值相加大于0，右指针往左移，反之，左指针向右移。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
        for (int i = 0; i < nums.length ; i++) {
            if(nums[i] > 0) return result;//第一个大于0，则后面相加肯定大于0
            if(i>0 && nums[i] == nums[i-1])  continue;//去重
            int l=i+1,r= nums.length-1;
            while(l < r){
                //至少一个答案，先不去重
                if(nums[i] + nums[l] + nums[r] >0) r--;
                else if(nums[i] + nums[l] + nums[r] <0) l++;
                else{
                    result.add(Arrays.asList(nums[i],nums[l],nums[r]));
                    while (r > l && nums[r] == nums[r - 1]) r--;
                    while (r > l && nums[l] == nums[l + 1]) l++;
                    r--;
                    l++;
                }
                
            }
        }
        return result;
    }
}

注意：

1.i指针移动的时候只能用 nums[i] == nums[i-1] 来去重，因为是左指针在i的右边，如果用nums[i] == nums[i+1] 可能导致结果被pass掉了

2.在while（）循环中，如果左右指针也需要去重，必须先将答案保存下来，不能在循环开始前就去重，这样的话答案就返回不了了，因为去完重之后可能l>r导致循环终止

4.利用双指针解四数之和

题目：四数之和

这道题与三数之和思路一样也是用双指针l，r遍历，只是多了一层for循环，需要注意的就i是target不是0了，所以不能直接用nums[k] >target来剪枝，因为即使已经排序，但是负数加上负数只会更小，所以不能这样判断，要加多一个nums[k]>0的条件。

这道题用双指针将时间复杂度从O(n^4)变成了O(n^3)，三数之和那道题也降了一级，可以知道双指针可以降低一级的时间复杂度，是很有利于ac的。 

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
        for (int k = 0; k < nums.length; k++) {
            if (nums[k] > 0 && nums[k] > target)
                return result; // 一级剪枝
            if (k > 0 && nums[k] == nums[k - 1])
                continue;// 去重
            for (int i = k + 1; i < nums.length; i++) {
                if (nums[i] + nums[k] > target && nums[k] > 0)
                    return result;// 二级剪枝
                if (i > k + 1 && nums[i] == nums[i - 1])
                    continue;// 去重
                int l = i + 1, r = nums.length - 1;
                while (l < r) {
                    // 至少一个答案，先不去重
                    if (nums[i] + nums[l] + nums[r] + nums[k] > target)
                        r--;
                    else if (nums[i] + nums[l] + nums[r] + nums[k] < target)
                        l++;
                    else {
                        result.add(Arrays.asList(nums[k], nums[i], nums[l], nums[r]));
                        while (r > l && nums[r] == nums[r - 1])
                            r--;
                        while (r > l && nums[l] == nums[l + 1])
                            l++;
                        r--;
                        l++;
                    }

                }
            }
        }
        return result;
    }
}

学习时长：3h

总结：今天学习时间比较赶，匆匆忙忙的学习了今天这章的知识，虽然学习到了map集合和双指针的更深的运用，但是可能在匆忙之中漏掉了一些关键信息，在之后会进行复习。