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

454.四数相加II

题目链接： 454.四数相加II
文档讲解：代码随想录
状态：没做出来，没想到考虑重复的情况！

题解：

public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        // 结果计数器
        int res = 0;
        // 临时变量用于存储和
        int sum = 0;
        // 用于存储 nums1 和 nums2 各元素和出现次数的哈希表
        HashMap<Integer, Integer> map = new HashMap<>();

        // 遍历 nums1 和 nums2 的所有组合
        for (int n1 : nums1) {
            for (int n2 : nums2) {
                // 计算两数之和
                sum = n1 + n2;
                // 将和存入哈希表，记录出现的次数. 记录出现的次数是为了处理输入数组中可能包含重复元素的情况。
                // 假设在 nums1 和 nums2 中有多个元素对 (n1, n2) 其和相同，在 nums3 和 nums4 中也可能有多个元素对 (n3, n4) 其和的负值相同。
                // 如果和已存在，则次数加1；否则，初始化为1
                map.put(sum, map.getOrDefault(sum, 0) + 1);
            }
        }

        // 遍历 nums3 和 nums4 的所有组合
        for (int n3 : nums3) {
            for (int n4 : nums4) {
                // 计算两数之和
                sum = n3 + n4;
                // 判断哈希表中是否存在与当前和相反的值
                if (map.containsKey(-sum)) {
                    // 如果存在，则结果计数器增加该和出现的次数
                    res += map.get(-sum);
                }
            }
        }
        // 返回结果计数器
        return res;

    }

383. 赎金信

题目链接： 383. 赎金信
文档讲解：代码随想录
状态：so easy

题解：

    public boolean canConstruct(String ransomNote, String magazine) {
        int[] counter = new int[26];

        char[] mChars = magazine.toCharArray();
        char[] rChars = ransomNote.toCharArray();

        for (char mChar : mChars) {
            counter[mChar - 'a']++;
        }

        for (char rChar : rChars) {
            if (counter[rChar - 'a'] > 0) {
                counter[rChar - 'a']--;
            } else {
                return false;
            }
        }
        return true;
    }

15. 三数之和

题目链接： 15. 三数之和
文档讲解：代码随想录
状态：没做出来

思路：
3 <= nums.length <= 3000，所以使用O($n^3$)复杂度的算法会时间超限。
可以考虑使用双指针：首先对数组进行排序，遍历数组时先固定一个数，然后使用双指针方法遍历数组，查找所有和为零的不重复三元组。在遍历过程中，双指针分别从当前元素之后和数组末尾开始，通过调整指针来找到满足条件的三元组，并通过跳过重复元素来避免重复结果。

题解：

    public List<List<Integer>> threeSum(int[] nums) {
        // 用于存储结果的列表
        List<List<Integer>> list = new ArrayList<>();
        // 将数组进行排序
        Arrays.sort(nums);
        for (int i = 0; i < nums.length - 2; i++) {
            // 排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果就可以了
            if (nums[i] > 0) {
                return list;
            }
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue; // 去重，避免重复计算相同的元素
            }

            int left = i + 1;
            int right = nums.length - 1;

            while (left < right) {
                int sum = nums[i] + nums[left] + nums[right];

                if (sum < 0) {
                    left++; // 当前和小于零，左指针右移
                } else if (sum > 0) {
                    right--; // 当前和大于零，右指针左移
                } else {
                    list.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--;
                    }

                    left++; // 继续寻找下一个解
                    right--;
                }
            }
        }
        return list;
    }

18. 四数之和

题目链接：18. 四数之和
文档讲解：代码随想录
状态：各种细节问题没处理好

题解：

    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++) {
            //注意:两个负数相加可以变得更加小,所以不能num[i]>target就break;所以使用nums[i]>0再剪枝
            if (nums[i] > 0 && nums[i] > target)
                return result;
            if (i > 0 && nums[i] == nums[i - 1]) {//i > 0防止下标越界
                continue; // 去重，避免重复计算相同的元素
            }
            for (int j = i + 1; j < nums.length; j++) {
                //二次剪枝
                if (nums[i] + nums[j] > target && target > 0)
                    break;
                //j > i + 1
                if (j > i + 1 && nums[j] == nums[j - 1]) {
                    continue; // 去重，避免重复计算相同的元素
                }
                int left = j + 1, right = nums.length - 1;
                while (left < right) {
                    int sum = nums[i] + nums[j] + nums[left] + nums[right];
                    if (sum < target) {
                        left++;
                    } else if (sum > target) {
                        right--;
                    } else {
                        result.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
                        // 去重，避免重复计算相同的元素,如[0,-1,-1,-1,1,1,1],取一次[0,-1,1]即可
                        while (left < right && nums[left] == nums[left + 1]) {
                            left++;//left右移,直至和后一位不相等
                        }
                        while (left < right && nums[right] == nums[right - 1]) {
                            right--;//left左移,直至和前一位不相等
                        }
                        left++; // 继续寻找下一个解
                        right--;
                    }
                }
            }
        }
        return result;
    }