代码随想录第 6 天 - 454 四数相加 II & 383 赎金信 & 15 三数之和 & 18 四数之和

链表

454 四数相加 II

原题链接

解题思路：
这道题最直观的就是四层 for 循环，但仔细观察一下，他只问的是组成四数之和的不同的下标组数。可以考虑用分组，两两 for 循环。前面 一个循环用 HashMap 收集前两个数组之和（key）和对应出现的次数（value）。后面循环将后两个数组的值和 HashMap 中的 key 进行比较，然后累加次数。

题解：
时间复杂度：O(n^2)
空间复杂度：O(n^2) ：也就是哈希表所占用的空间。本题最坏条件下，两个数组的数和都不同，就会有 n * n 个数加入哈希表。

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        // 用HashMap存储nums1+nums2两个数组和，value为二者和出现的次数
        Map<Integer, Integer> map = new HashMap<>();
        for (int n1 : nums1) {
            for (int n2 : nums2) {
                map.put(n1 + n2, map.getOrDefault(n1 + n2, 0) + 1);
            }
        }
        int count = 0;
        for (int n3 : nums3) {
            for (int n4 : nums4) {
                // 遍历nums3和nums4的和，当满足与map中nums1和nums2相加为0时收集结果
                count += map.getOrDefault(0 - (n3 + n4), 0);
            }
        }
        return count;
    }
}

383 赎金信

原题链接

解题思路：
非常直观用哈希表的一题。记得用 int 数组优化！

题解：
时间复杂度：O(n)
空间复杂度：O(1)

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        int[] freq = new int[26];
        for (char m : magazine.toCharArray()) {
            freq[m - 'a']++;
        }
        for (char r : ransomNote.toCharArray()) {
            if (freq[r - 'a'] == 0) return false;
            freq[r - 'a']--;
        }
        return true;
    }
}

15 三数之和

原题链接

解题思路：
刚做这道题的时候有点先入为主，想当然以为这道题要用哈希表，但感觉会实在很麻烦，便开始想新思路。
开始排序，遍历一个下标，剩下两个数用双指针，结果成了！假设三个数分别是 a、b、c，分别对应就是 nums[i], nums[left], nums[right]。由题意 i，j，k 不能相等可得知，三个下标不能相同。所以将 left = i + 1，将 right = nums.length - 1。然后双指针使用 while 循环，仅当 left > right 时退出循环。当三者之和相等时收集结果，sum > 0 时，让 right--；sum < 0 时，left++。
这道题还有一个关键点在去去重，需要对 a，b，c 分别去重。当 a/b/c 和前一个值相同时可以直接跳过/收缩。

优化：

• 在每次 for 循环开始时，因为数组是排好序的，可以先判断最小的三个数之和是否大于0，如果最小的三个数都大于0，则可以直接break。
• 在每次双指针开始前，先算下当前最大的三个数之和是否小于0，如果是的话，可以直接 continue 到下一个 nums[i]。这里不用 break 的原因是因为下一个 a 可能更大，后面可能还是会存在满足条件的结果的。

题解：
时间复杂度：O(n^2)
空间复杂度：O(1)

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        // 给数组进行排序
        Arrays.sort(nums);
        List<List<Integer>> res = new ArrayList<>();
        for (int i = 0 ; i < nums.length; i++) {
            // 当前三个最小的数相加都大于0时，后面所有组合都会大于0，这时可以直接返回
            if (i + 2 < nums.length && nums[i] + nums[i + 1] + nums[i + 2] > 0) break;

            // 对重复的a进行去重
            if (i != 0 && nums[i - 1] == nums[i]) continue;
            // 双指针
            int left = i + 1;
            int right = nums.length - 1;

            // 双指针时，当最大的两个数相加后都小于0，可以直接跳过这次循环，等待下一个更大的 nums[i]
            if (nums[i] + nums[right] + nums[right - 1] < 0) continue;
            
            while (left < right) {
                int sum = nums[i] + nums[left] + nums[right];
                if (sum == 0) {
                    res.add(Arrays.asList(nums[i], nums[left], nums[right]));
                    // 分别对b和c去重
                    while(left < right && nums[left] == nums[left + 1]) left++; 
                    while(left < right && nums[right] == nums[right - 1]) right--;
                    // 双指针同时收缩
                    left++;
                    right--;
                } else if (sum > 0) {
                    right--;
                } else {
                    left++;
                }
            }
        }
        return res;
    }
}

18 四数之和

原题链接

解题思路：
和三数之和一个思路。只是多嵌套了一层 for 循环。

题解：
时间复杂度：O(n^3)
空间复杂度：O(1)

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        Arrays.sort(nums);
        List<List<Integer>> res = new ArrayList<>();

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

今日心得

比印象中要难，关键在于去重和优化！加油，思路要比第一遍清晰很多了！