[Day6]代码随想录

**今日内容：454.四数相加||，383.赎金信，15.三数之和，18.四数之和，总结 **
代码随想录链接：代码随想录 (programmercarl.com)

454.四数相加||

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

• 0 <= i, j, k, l < n
• nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

这道题如果用传统的遍历的方法，时间复杂度要上O(n^4);为了减少个时间复杂度，考虑使用哈希表。

先用四个HashMap存储四个数组，key值为元素值，value值为对应的数组下标，然后再创建一个hashSet，计算已经存储过的（i,j,k,l）。

然后发现貌似也没有减少时间复杂度，学一下。

本题解题步骤：

1. 首先定义 一个unordered_map，key放a和b两数之和，value 放a和b两数之和出现的次数。
2. 遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中。
3. 定义int变量count，用来统计 a+b+c+d = 0 出现的次数。
4. 在遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。
5. 最后返回统计值 count 就可以了

代码如下：

import java.util.HashMap;
import java.util.Map;
class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int count = 0;
        Map<Integer,Integer> sum1 = new HashMap<Integer,Integer>();
        for(int i : nums1){
            for(int j : nums2){
                int sum = i + j;
                if(sum1.get(sum) == null){
                    sum1.put( sum, 1);
                }
                else{
                    sum1.put(sum , sum1.get(sum) + 1);
                }
            }
        }
        for(int i : nums3){
            for(int j :nums4){
                if(sum1.get(0 - i - j) != null){
                    count = count + sum1.get(0 - i - j);
                }
            }
        }
        return count;
    }
}

时间复杂度O（n²），空间复杂度O（1）
因为每个数组都会选取一个数字，所以对于每一个单独的数组来说，count是一样的，对于两个数组的组合来说，count也是一样的。因此当我们只需要保存a+b的和的出现次数，当出现c+d满足条件时，就可以直接加上count，妙啊。

同时官方答案给出了更简洁的写法：

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int res = 0;
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        //统计两个数组中的元素之和，同时统计出现的次数，放入map
        for (int i : nums1) {
            for (int j : nums2) {
                int sum = i + j;
                map.put(sum, map.getOrDefault(sum, 0) + 1);
            }
        }
        //统计剩余的两个元素的和，在map中找是否存在相加为0的情况，同时记录次数
        for (int i : nums3) {
            for (int j : nums4) {
                res += map.getOrDefault(0 - i - j, 0);
            }
        }
        return res;
    }
}

map.put(sum, map.getOrDefault(sum, 0) + 1);通过调用map.getOrDefault(sum, 0)实现了计数，原理和上面的我写的判断一样。

383.赎金信

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

这道题，似曾相识，感觉和那个字母异位词很像，那道题用的数组，这个用的，代码如下：

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

时间复杂度O（n），空间复杂度O（1） 判定条件是，一旦record出现了负值，说明杂志提供的这个字母的数量不够，因此返回false。

我看官方答案在开头加了个两个字符串长度的比较，当杂志字符串长度小于赎金信的时候，返回false，但是这种情况被下面的判断包括了，可能能节省运算吧。

tips：这题可也以暴力求解，就是时间复杂度比较高O（n²）

15.三数之和

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。 注意： 答案中不可以包含重复的三元组。

这道题如果暴力的话，三个循环是可以解决的吧，但是去重很麻烦，写了半天没写出来。。。

哈希法

首先先给数组排序，可以方便很多,比如可以不用比较i、j、k是否相等，第一个数字一定是非正数等等性质。（我一直没想到）

按照代码随想录里的C++代码，想写java版本的，没写出来，有点麻烦，学习了一圈后，换一个思路：
创建一个Set用于三元组的去重(去重前排序，避免顺序不同的相同数组出现)，就不需要复杂度去重判定了。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        Set<Integer> set = new HashSet<Integer>();
        for(int i = 0; i < nums.length - 2; i++){
            Map<Integer,Integer> map = new HashMap<Integer,Integer>();
            for(int j = x + 1; j < nums.length - 1; j++){
                int sum = 0 - nums[i] - nums[j];
                if(map.containsKey(sum)){
                    List<Integer> add = Array.asList(nums[i], nums[j], sum);
                    Collectiong.sort(add);
                    set.add(add); 
                }
                else{
                    map.put(nums[j],nums[j]);
                }
            }
        }
        return new ArrayList<>(set);
    }
}

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

双指针法

先整体的排序一下
把三数之和换成两数之和的问题，也就是先用i循环一遍，再用双指针
找到数字后用hashset防止重复

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
	// 找出a + b + c = 0
        // a = nums[i], b = nums[left], c = nums[right]
        for (int i = 0; i < nums.length; i++) {
	    // 排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果就可以了
            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) {
                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;
    }
}

说到去重，其实主要考虑三个数的去重。 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;
}

这么写就是当前使用 nums[i]，我们判断前一位是不是一样的元素，在看 {-1, -1 ,2} 这组数据，当遍历到 第一个 -1 的时候，只要前一位没有-1，那么 {-1, -1 ,2} 这组数据一样可以收录到 结果集里。

这是一个非常细节的思考过程。

18.四数之和

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

• 0 <= a, b, c, d < n
• a、b、c 和 d 互不相同
• nums[a] + nums[b] + nums[c] + nums[d] == target 你可以按 任意顺序 返回答案 。

这题在上一题的基础上加一层for循环即可，代码如下：

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;
            }
            
            if (i > 0 && nums[i] == nums[i - 1]) {  // 去重a
                continue;
            }
            for(int j = i + 1; j < nums.length; j++){
                if(j > i + 1 && nums[j] == nums[j -1]){
                        continue;
                }
                int left = j + 1;
                int right = nums.length - 1;
                while (right > left) {
                int sum = 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[right] == nums[right - 1]) right--;
                    while (right > left && nums[left] == nums[left + 1]) left++;              
                    right--; 
                    left++;
                }
                }
            }
        }
        return result;
    }
}

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

那么一样的道理，五数之和、六数之和等等都采用这种解法。 双指针法可以让时间复杂度少一次方，对于15.三数之和 (opens new window)双指针法就是将原本暴力O(n^3)的解法，降为O(n^2)的解法，四数之和的双指针解法就是将原本暴力O(n^4)的解法，降为O(n^3)的解法。

双指针法将时间复杂度：O(n^2)的解法优化为 O(n)的解法。

---

结束，本来打算周日看一看前面的内容，结果已经周日晚快十点了。遗憾离世。