[二刷] 代码随想录算法训练营第七天| 454. 四数相加 II、383. 赎金信、15. 三数之和、18. 四数之和-优快云博客

本文链接：https://blog.youkuaiyun.com/dreamtang/article/details/140689500

[LeetCode] 454. 四数相加 II

[KamaCoder] 454. 四数相加 II 文章解释

[LeetCode] 454. 四数相加 II

从四个数组里分别选出一个数, 计算一共有多少种组合, 可以让选出来的四个数的和等于预期的值.

核心思想: 遍历其中两个组合, 用一个 Map 记录住这两个数组所有数字的和以及和对应的数字的组合的数量. 遍历另外两个组合, 去 Map 里查是否存在与和相反的 key, 如果存在则知道这两个数字可以和另外 N 个组合相加, 结果为预期的值(函数参数中传入).

整体还是很简单的, 就是每次刚看脑子都转不过来, 这就叫天赋缺失...

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        Map<Integer, Integer> sumCount = new HashMap<>();
        for (int number1 : nums1) {
            for (int number2 : nums2) {
                int sum = number1 + number2;
                int count = sumCount.getOrDefault(sum, 0);
                sumCount.put(sum, ++count);
            }
        }
        int result = 0;
        for (int number3 : nums3) {
            for (int number4 : nums4) {
                int sum = -(number3 + number4);
                result += sumCount.getOrDefault(sum, 0);
            }
        }
        return result;
    }
}

[LeetCode] 383. 赎金信

[KamaCoder] 383. 赎金信文章解释

[LeetCode] 383. 赎金信

因为所有字母都为小写字母, 所以哈希表可以用 new int[26], 否则需要用一个 Map<Character, Integer>.

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

[LeetCode] 15. 三数之和

[KamaCoder] 15. 三数之和文章解释

[LeetCode] 15. 三数之和

三数之和和四数之和都是双指针思维, 三数之和用哈希表也可以做, 但是哈希表的生成稍微有点小技巧.

三数之和和四数之和的双指针思想其实都是遍历所有的元素, 遍历的方法是, 固定最左边的 n - 2 个元素, 这 n - 2 个元素使用暴力遍历的方式, 剩下的两个元素则使用 left + right 的双指针, 通过 left++ & right-- 的方式逼近结果.

class Solution {
    public List<List<Integer>> threeSum(int[] numbers) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(numbers);
        for (int i = 0; i < numbers.length; i++) {
            if (numbers[i] > 0) {
                break;
            }
            if (i > 0 && numbers[i] == numbers[i - 1]) {
                continue;
            }
            int left = i + 1;
            int right = numbers.length - 1;
            while (left < right) {
                int sum = numbers[i] + numbers[left] + numbers[right];
                if (sum == 0) {
                    result.add(Arrays.asList(numbers[i], numbers[left], numbers[right]));
                    while (left < right && numbers[left] == numbers[++left]) {}
                    while (left < right && numbers[right] == numbers[--right]) {}
                } else if (sum > 0) {
                    while (left < right && numbers[right] == numbers[--right]) {}
                } else {
                    while (left < right && numbers[left] == numbers[++left]) {}
                }
            }
        }
        return result;
    }
}

class Solution {
    public List<List<Integer>> threeSum(int[] numbers) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(numbers);
        for (int i = 0; i < numbers.length; i++) {
            if (i > 0 && numbers[i] == numbers[i - 1]) {
                continue;
            }
            Set<Integer> exists = new HashSet<>();
            for (int j = i + 1; j < numbers.length; j++) {
                // 下面的去重可以通过: 0 0 0 0 与 -4 0 0 2 2
                if (j > i + 2 && numbers[j] == numbers[j - 1] && numbers[j - 1] == numbers[j - 2]) {
                    continue;
                }
                int sum = numbers[i] + numbers[j];
                if (exists.contains(-sum)) {
                    result.add(Arrays.asList(numbers[i], numbers[j], -sum));
                    exists.remove(-sum);
                } else {
                    exists.add(numbers[j]);
                }
            }
        }
        return result;
    }
}

[LeetCode] 18. 四数之和

[KamaCoder] 18. 四数之和文章解释

[LeetCode] 18. 四数之和

四数之和与三数之和一样, 不过剪枝的操作会多一些.

核心思想为: 暴力遍历前两个数字, 后两个数字使用 left++ && right-- 双指针逼近结果, 达到剪枝的效果.

class Solution {
    public List<List<Integer>> fourSum(int[] numbers, int target) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(numbers);
        for (int i = 0; i < numbers.length - 3; i++) {
            if (i > 0 && numbers[i] == numbers[i - 1]) {
                continue;
            }
            if ((long)numbers[i] + numbers[i + 1] + numbers[i + 2] + numbers[i + 3] > target) {
                break;
            }
            if ((long)numbers[numbers.length - 4] + numbers[numbers.length - 3] + numbers[numbers.length - 2] + numbers[numbers.length - 1] < target) {
                break;
            }
            for (int j = i + 1; j < numbers.length - 2; j++) {
                if (j > i + 1 && numbers[j] == numbers[j - 1]) {
                    continue;
                }
                if ((long)numbers[i] + numbers[j] + numbers[j + 1] + numbers[j + 2] > target) {
                    break;
                }
                int left = j + 1;
                int right = numbers.length - 1;
                while (left < right) {
                    long sum = (long)numbers[i] + numbers[j] + numbers[left] + numbers[right];
                    if (sum == target) {
                        result.add(Arrays.asList(numbers[i], numbers[j], numbers[left], numbers[right]));
                        while (left < right && numbers[left] == numbers[++left]) {}
                        while (left < right && numbers[right] == numbers[--right]){}
                    } else if (sum > target) {
                        right--;
                    } else {
                        left++;
                    }
                }
            }
        }
        return result;
    }
}