第三章哈希表part02 454.四数相加II 383. 赎金信 15. 三数之和 18. 四数之和-CSDN博客

本文链接：https://blog.csdn.net/qq_45498567/article/details/132306434

第七天| 第三章哈希表part02 454.四数相加II 383. 赎金信 15. 三数之和 18. 四数之和

454.四数相加II

题目链接：https://leetcode.cn/problems/4sum-ii/
文章讲解：https://programmercarl.com/0454.%E5%9B%9B%E6%95%B0%E7%9B%B8%E5%8A%A0II.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
题目介绍：给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：
- 0 <= i, j, k, l < n
- nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

解法：

思路：解法还是哈希表，可以这么想：将数组划分为两组，遍历前两个数组中的每一个元素，两两相加得到的值a+b放入一个map的key中，map的value用来存放这个值出现的次数。得到这样一个map后，在遍历剩余的两个数组，还是两两相加求和c+d，判断在这个map中是否存在a+b = 0-(c + d)，如果存在就将count加上这个数值key对应的value。

代码：

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int count = 0;
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int a : nums1) {
            for (int b : nums2) {
                // a + b
                int temp = 1;
                if (map.containsKey((a + b))) {
                    int value = map.get(a + b);
                    map.put((a + b), ++value);
                } else {
                    map.put((a + b), temp);
                }
            }
        }
        for (int c : nums3) {
            for (int d : nums4) {
                // 判断map中是否出现 0 - (c + d)，如果出现了，就让count加上其对应在map中的value
                if (map.containsKey(0 - c - d)) {
                    count += map.get((0 - c - d));
                }
            }
        }
        return count;
    }
}

以上代码中判断的部分可以通过map的一个函数进行简化：
- map.getOrDefault(key, default)：获取kety对应的value，如果没获取到就返回default
所以，上述代码简化为：

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

383.赎金信

题目链接：https://leetcode.cn/problems/ransom-note/
文章讲解：https://programmercarl.com/0383.%E8%B5%8E%E9%87%91%E4%BF%A1.html#%E6%80%9D%E8%B7%AF
题目介绍：给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。

示例 1：
```
输入：ransomNote = "a", magazine = "b"
输出：false
```
解法：
- 思路：此题目与哈希表part01的第一题“有效的字母异位词”类似，在那道题目中判断的是字符串s与字符串t是否可以相互组成，即字母是相同的，但是位置不同。但是本题的要求是判断 ransomNote 能不能由 magazine 里面的字符构成，并且magazine中的每个字母只能在ransomNote中出现一次，其中，ransomNote 和 magazine 由小写英文字母组成。
  - 需要注意的是：
    - （1）如果ransomNote的长度大于magazine的长度，那么一定是false；
    - （2）用数组存放magazine的字母出现的次数，用ransomNote去判断这个数组，如果数组中出现小于0的数说明ransomNote中存在不属于magazine的字母。简单来说就是：ransomNote是magazine的子集（ransomNote中的字母出现的类型和个数必须小于等于magazine）。
- 代码：
  - ```
  class Solution {
      public boolean canConstruct(String ransomNote, String magazine) {
                  if (ransomNote.length() > magazine.length()) {
              return false;
          }
          int[] record = new int[26];
          for (int i = 0; i < magazine.length(); i++) {
              record[magazine.charAt(i) - 'a']++;
          }
          for (int i = 0; i < ransomNote.length(); i++) {
              record[ransomNote.charAt(i) - 'a']--;
          }
          for (int i : record) {
              if (i < 0) {
                  return false;
              }
          }
          return true;
      }
  }
```

15.三数之和（判断三数相加是否等于0，返回结果集）

题目链接：https://leetcode.cn/problems/3sum/
文章讲解：https://programmercarl.com/0015.%E4%B8%89%E6%95%B0%E4%B9%8B%E5%92%8C.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
题目介绍：给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。注意： 答案中不可以包含重复的三元组。
解法：
- 思路：
  - 这道题的关键是不能有重复的三元组（注意是三元组不能重复，并不是三元组内的元素不能重复）；
  - 之前做过的两数之和，采用的是哈希表解决，思路是用一个map存储值nums[i]和对应的下标i，再判断这个map中是否保存了target-nums[i]，如果保存了则返回当前的下标和target-nums[i]对应的下标。
  - 这道题也可以采用同样的思路，因为是三个数，所以需要写两层for循环遍历，并且这道题涉及到了去重的问题，所以哈希表并不是一个好的选择。这里提供一个思路：双指针法。（n数之和，n大于2都采用双指针）。
  - 具体有以下三个细节：
    - （1）剪枝（剪枝操作）：首先给数组排个序，因为是排序之后的数组，如果nums[i] > 0，那么之后的数一营不满足相加等于0，所以直接返回。
    - （2）双指针具体是怎么操作呢？（双指针遍历）
    - [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X2YgM7Tv-1692101748007)(image-20230815185157199.png)]
      - 首先给数组排个序（这是关键的一步）；
      - 其次遍历数组，数组中的元素为nums[i]，然后再定义一个left和一个right，通过判断nums[i] + left + right 大于小于还是等于0，来移动left和right。例如：如果nums[i] + left + right > 0，则right–；如果nums[i] + left + right < 0，则left++。如果找到了等于0的结果集，就让left++，right–。
      - 终止的条件是left >= right。因此上述循环的条件是left < right
    - （3）如何去重？（去重操作）
      - 首先对于nums[i]而言，如果nums[i] == nums[i - 1]，就直接跳出循环，为什么呢？因为前一个数和当前数是相等的，前一个数已经将所有的可能性都遍历，并加入到结果集当中了，如果你再遍历一遍，一定是重复的。
      - 对于left和right是一样的。left < right时，如果当前的left和下一个left对应的值相等，直接让left向数组的中间靠拢；如果right和上一个right对应的值相等，也是直接让right向数组的中间靠拢。
    - 答题顺序：排序 ------> 剪枝 ------> 去重 ------> 操作双指针
- 代码：
  - ```
  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;
              }
              if (i > 0 && nums[i - 1] == nums[i]) {
                  continue;
              }
              int left = i + 1;
              int right = nums.length - 1;
              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 (left < right && nums[left] == nums[left + 1]) {
                          left++;
                      }
                      while (left < right && nums[right] == nums[right - 1]) {
                          right--;
                      }
                      right--;
                      left++;
                  }
              }
          }
          return result;
      }
  }
```

18.四数之和（判断三数相加是否等于target，返回结果集）

题目链接：https://leetcode.cn/problems/4sum/
文章讲解：https://programmercarl.com/0018.%E5%9B%9B%E6%95%B0%E4%B9%8B%E5%92%8C.html
题目介绍：给你一个由 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循环，并且同样都需要剪枝，双指针遍历和去重操作。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FzkCBrYu-1692101748008)(image-20230815185249868.png)]

这里需要注意细节的是：

（1）去重操作：因为与三数之和不同的是，本题的要求是与target对比，所以剪枝的时候不能一味的大于0就可以，需要这样判断。

if (nums[i] > 0 && nums[i] > target) {
    return result;
    // 在外层循环，满足上面的条件，就不用遍历后面的数了，一定不存在结果集
}

在里面的for循环中，也可以进行剪枝：

if (nums[j] + nums[i] > 0 && nums[i] + nums[j] > target){
    // 在内层循环，把内层循环break就好，还是要接着遍历外层循环的
    break;
}

（2）nums[k] + nums[i] + nums[left] + nums[right] > target int会溢出，所以提升为long类型。

代码：

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