代码随想录算法训练营第七天 454.四数相加 Ⅱ、383.赎金信、15.三数之和、18.四数之和

454.四数相加 Ⅱ

题目链接：454.四数相加 Ⅱ

视频教程

文字教程

思路

本题的思路跟两数之和的思路有点像

难点在于：将时间复杂度从 n⁴ 降为 n²

解决方式：利用map将四个数组两两分开，分别计算两组的和并存入hashmap ，这样时间复杂度就变成了 2 * n²

key为两数之和，value为两数之和在这组中出现的次数

代码实现

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int count = 0;
        Map<Integer, Integer> hash = new HashMap<>(); // nums3 + nums4的数值
        for (int i = 0;i < nums3.length;i++) { // key是nums3 + nums4数值, value是元素数值在nums4中出现的次数
            for (int j = 0;j < nums4.length;j++) {
                int sum1 = nums3[i] + nums4[j];
                if (hash.containsKey(sum1)) { // 如果已经出现过，那么将次数+1
                    int n = hash.get(sum1);
                    hash.put(sum1, ++n);
                } else { // 没出现过就添加进去次数设为1
                    hash.put(sum1, 1);
                }
            }
        }
        for (int i = 0;i < nums1.length;i++) {
            for (int j = 0;j < nums2.length;j++) {
                int x = nums1[i] + nums2[j]; // 前两个数相加
                if (hash.containsKey(-x)) { // 如果nums3+nums4中有与x相加为0的数值, 那么count就加上这个数值在hash中出现的次数
                    count += hash.get(-x);
                }
            }
        }
        return count;
    }
}

---

383.赎金信

题目链接：383.赎金信

文字教程

思路

在使用哈希法时，能用数组用数组，数组的时间消耗大部分情况下时最小的。本题其实也可以使用map，但map的开销更大。

代码实现

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

---

15.三数之和

题目链接：15.三数之和

视频教程

文字教程

双指针

这道题使用哈希法并不十分合适，因为在去重中需要在意很多细节。

所以我们使用双指针法，动画如下：

拿这个nums数组来举例，首先必须将数组排序，然后有一层for循环，i 从0开始，同时定一个 left 在 i + 1 位置上，再定义一个 right在数组结尾的位置上。

数组排序是使用双指针的基础

在数组中找到abc，使得 a + b + c = 0，我们这里 a = nums[i]，b = nums[left]，c = nums[right]。

接下来 left 和 right 怎么移动呢，如果 sum > 0，那么就让 right 左移。反之亦然。

去重逻辑

在去重中，必须先处理前面的，去重 后面重复的 ，a b c 的去重都是这个道理

• a的去重：

  if (i > 0 && nums[i] == nums[i - 1]) { 
      continue;
  }
  

  注意这里必须是 nums[i] == nums[i - 1] 而不是 nums[i] == nums[i + 1] ，可以思考 [0, 0, 0] 这种情况，后者会直接跳过。

• b，c 去重：

  while (left < right && nums[left] == nums[left + 1]) left++;
  while (left < right && nums[right] == nums[right - 1]) right--;
  

代码实现

时间复杂度：O(n²) （双指针将里面的b c循环复杂度从 n² 降为 n）

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> list = new ArrayList<>();
        Arrays.sort(nums); // 对数组进行从小到大的排序
        for (int i = 0;i < nums.length;i++) {
            if (nums[i] > 0) { // 如果元素a都大于0，则a+b+c一定大于0
                break;
            }
            if (i > 0 && nums[i] == nums[i - 1]) { // a去重 不能与后一项比较因为会跳过[0, 0, 0]
                continue;
            }
            int left = i + 1; // b元素，左指针
            int right = nums.length - 1; // c元素，右指针
            while (left < right) { // b元素和c元素不能是同一个数值，题目要求不重复
                int sum = nums[i] + nums[left] + nums[right]; 
                if (sum > 0) {  
                    right--;
                } else if (sum < 0) {
                    left++;
                } else {
                    list.add(Arrays.asList(nums[i], nums[left], nums[right])); // 将结果存入list中
                    while (left < right && nums[left] == nums[left + 1]) { // b去重
                        left++;
                    }
                    while (left > right && nums[right] == nums[right - 1]) { // c去重
                        right--;
                    }
                    left++;
                    right--;
                }

            }
        }
        return list;
    }
}

---

18.四数之和

题目链接：18.四数之和

视频教程

文字教程

思路

本题与 三数之和 解法基本相同，就是在三数之和的外面多加了一层for循环

对第一层剪枝也略有不同，因为负数越加越大，所以必须 nums[k] > 0。

代码实现

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> list = new ArrayList<>();
        Arrays.sort(nums);
        // k i left right
        for (int k = 0;k < nums.length;k++) { // 第一次循环
            if (nums[k] > target && nums[k] > 0) { // 对第一层 剪枝, 必须nums[k] > 0, 因为负数越加越大
                break;
            }
            if (k > 0 && nums[k] == nums[k - 1]) { // 对第一层 去重
                continue;
            }
            for (int i = k + 1;i < nums.length;i++) { // 第二层循环
                if (i - 1 > k && nums[i] == nums[i - 1]) { // 第二层去重
                    continue;
                }
                int left = i + 1; // 定义双指针去循环剩余两层
                int right = nums.length - 1;
                while (left < right) {
                    int sum = nums[k] + nums[i] + nums[left] + nums[right];
                    if (sum > target) {
                        right--;
                    } else if (sum < target) {
                        left++;
                    } else {
                        list.add(Arrays.asList(nums[k], nums[i], nums[left], nums[right])); // 添加目标数组
                        // 对第三层和第四层去重
                        while (left < right && nums[left] == nums[left + 1]) left++;
                        while (left < right && nums[right] == nums[right - 1]) right--;
                        left++;
                        right--;
                    }
                }
            }
        }
        return list;
    }
}