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

第七天| 第三章 哈希表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;
          }
      }