代码随想录训练营D7-哈希表篇p2 | 454.四数相加II 、383. 赎金信 、15. 三数之和 、18. 四数之和

（一） 454.四数相加II

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

题目/文章/视频链接

1. 思路

普通思路，一定是4层for循环。

使用map的思路。
count变量，记录元祖的个数。
数组1、2可能中任选两个数相加，可能组成的和放入map（key：两数之和；value：出现的次数）。
再遍历数组3、4 ，两数组中也是各取一个元素求和；若当前数n，在map中有0 - n吗，若有将其value加在count上。

2. 代码

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

3. 实现过程中的问题

按foreach写法时，遍历的n已经就是元素了，而不是下标

for(int n : nums4){
    sum = m + n;
    count += map.getOrDefault(0 - sum, 0);
}

（二） 383. 赎金信

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

题目/文章/视频链接

题干：
给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。
如果可以，返回 true ；否则返回 false 。
magazine 中的每个字符只能在 ransomNote 中使用一次。
（magazine提供字母）

1. 思路

使用哈希。数组的那种哈希。
1.创建一个长度为26的数组。
2.读入magazine。key，即数组下标为：当前char-’a‘；value: 该字母的个数。
3.读入ransom。遍历时，用到一个字母，就将对应的value–；同时判断，若该value为负数了，则返回false。
4.最后返回true

2. 代码

public boolean canConstruct(String ransomNote, String magazine) {
    int[] array = new int[26];
    for(int i = 0; i < magazine.length(); ++i){
        array[magazine.charAt(i) - 'a']++;
    }

    for(int j = 0; j < ransomNote.length(); ++j){
        if(--array[ransomNote.charAt(j) - 'a'] < 0){
            return false;
        }
    }
    return true;
}

（三） 15. 三数之和

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

题目/文章/视频链接

1. 思路

双指针法。
由于这里不需要返回元素的下标，所以可以对其进行排序。
for循环遍历，在其下一个位置、数组末端各设置一个指针p，q。
三数相加，等于0 就把三个数存进数组中。

亿些细节：
for循环的当前值若大于0，则后面的p、q也一定>0。三数之和不可能为0 了，可以跳出循环了。
for循环，i只要不是第一个元素(即下标为0 时)，i都要和前一个元素i-1比较，如果相同则可以跳过了，即continue；
（p前进时、q后退时 也都要与上一个元素比较，看是否相同了，相同了就跳过。）
只有三数之和为0之后，再移动p、q时 才需要考虑去重。还没有找到合适的三数之前是不用考虑去重的，因为这根本就不是以后的准结果，何谈去重。

2. 代码

public List<List<Integer>> threeSum(int[] nums) {
    List<List<Integer>> result = new ArrayList<>();

    //1.对数组排序
    Arrays.sort(nums);
    int len = nums.length;

    //i作为第一个元素 其范围是 0<= i <= n-3
    int j, k;
    int sum = 0;
    for(int i = 0; i < len-2; ++i){
        if (nums[i] > 0) {
            break;
        }
        if(i != 0 && nums[i] == nums[i-1]){
            continue;
        }

        j = i + 1;
        k = len - 1;
        while (j < k){
            sum = nums[i] + nums[j] + nums[k];
            if(sum == 0){
                //添加元素的同时，完成了jk指针的移动
                result.add(Arrays.asList(nums[i], nums[j++], nums[k--]));
                //j、k 同i一样 若新值与旧值相同 则继续跳下一个
                while(j < k && nums[j-1] == nums[j]){
                    j++;
                }
                while(k > j && nums[k+1] == nums[k]){
                    k--;
                }
            }else if(sum > 0){//k所指的数字大了，k应向左移
                --k;
            }else {
                ++j;
            }

        }
    }
    return result;

}


public List<List<Integer>> threeSum1(int[] nums) {
    Arrays.sort(nums);
    int p, q;
    int len = nums.length;
    int threeSum;
    List<List<Integer>> result = new ArrayList<>();

    for(int i = 0; i < len; ++i){
        if(nums[i] > 0){
            break;
        }
        if(i > 0 && nums[i] == nums[i - 1]){
            continue;
        }
        //初始化pq
        p = i + 1; q = len - 1;
        while(p < q){
            threeSum = nums[i] + nums[p] + nums[q];
            if(threeSum > 0){//数大了，要小一点
                --q;
            }else if(threeSum < 0){
                ++p;
            }else {
                result.add(Arrays.asList(nums[i], nums[p], nums[q]));
                //继续移动p q
                //当前nums[p],右侧下一个值nums[p+1]
                while(p < q && nums[p] == nums[p + 1]){
                    ++p;
                }
                while(p < q && nums[q] == nums[q - 1]){
                    --q;
                }
                //当与下一个值都不一样时，到了这里，但还没有移动到下一个值的位置
                ++p; --q;
            }
        }

    }
    return result;

}

3. 实现过程中的问题

要清除的知道，在什么时刻对三个数去重。
i在for循环中起始时就要对i去重。
左侧指针、右侧指针：都是在三数之和为0之后。

（四） 18. 四数之和

建议： 要比较一下，本题和 454.四数相加II 的区别，为什么 454.四数相加II 会简单很多，这个想明白了，对本题理解就深刻了。 本题 思路整体和 三数之和一样的，都是双指针，但写的时候 有很多小细节，需要注意，建议先看视频。

题目/文章/视频链接

1. 思路

整体思路与三数之和基本一致。
在三数之和的基础上，i的for循环遍历上，再加一层j的for循环。
并且四数之和的剪枝与三数之和的剪枝有区别。
三数之和判断num[i] > 0 就break了，因为后面的数都比num[i]大，即都>0，所以无法再在后面找到两个数与num[i] 相加 == 0了 .
四数之和，不能num[i] + num[j] > target 就break了。现在比target大，但是num[i] + num[j] 不一定是个正数。若是负数，虽然现在比target大，但右面还有一些负数，四数相加还是有机会 等于 target的。

可以通过这种方式剪枝，nums[i] > target && nums[i] >=0

与四数之和II的区别。四数之和II是在四个数组中分别选数，不用像这里选每个数时都要错开(各种+1)，还要排重。

2. 代码

public List<List<Integer>> fourSum1(int[] nums, int target) {
    List<List<Integer>> result = new ArrayList<>();
    Arrays.sort(nums);//排序

    int left, right, sum;
    int len = nums.length;

    for(int i = 0; i < len; ++i){
        //剪枝 去重
        if(nums[i] > target && nums[i] > 0){
            break;
        }
        if(i > 0 && nums[i] == nums[i - 1]){
            continue;
        }

        for(int j = i + 1; j < len; ++j){
            //去重
            if(j > i + 1 && nums[j] == nums[j - 1]){
                continue;
            }
            left = j + 1;
            right = len - 1;
            while(left < right){
                sum = nums[i] + nums[j] + nums[left] + nums[right];
                if(sum > target){
                    --right;
                }else if(sum < target){
                    ++left;
                }else {
                    //找到目标组合了,同时迈出了left right向内靠拢的一步
                    result.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;
                    }

                }
            }

        }
    }
    return result;
}