代码随想录算法训练营--打卡day6-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_65528013/article/details/147025998

一.四数相加

1.题目链接

2.思路

使用 HashSet 无法记录每种和出现的次数，当不同的 (nums1[i], nums2[j]) 组合得到相同的和时，会出现统计错误。这里应该使用 HashMap 来记录和以及其出现的次数

3.代码

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        Map<Integer,Integer>map=new HashMap<>();
        for(int i=0;i<nums1.length;i++){
            for(int j=0;j<nums2.length;j++){
                 int sum=nums1[i]+nums2[j];
                 map.put(sum,map.getOrDefault(sum,0)+1);
            }
        }
        int res=0;
        for(int i=0;i<nums3.length;i++){
            for(int j=0;j<nums4.length;j++){
                int target=0-(nums3[i]+nums4[j]);
                if(map.containsKey(target)){
                   res=res+map.get(target);
                }
            }
        }
        return res;
    }
}

二.题目链接

1.题目链接

383. 赎金信 - 力扣（LeetCode）

2.代码

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

三. 三数之和

1.题目链接

15. 三数之和 - 力扣（LeetCode）

2.思路

排序：先对数组进行排序，这样方便后续使用双指针法，并且便于去重操作。
遍历数组：从第一个元素开始遍历，将当前元素作为三元组中的第一个元素 a。
双指针法：在当前元素之后的部分使用双指针 left 和 right 分别指向剩余元素的首尾，计算三数之和 sum。
若 sum 大于 0，说明 right 指向的元素过大，将 right 左移。
若 sum 小于 0，说明 left 指向的元素过小，将 left 右移。
若 sum 等于 0，找到一个满足条件的三元组，添加到结果列表中，并对 left 和 right 进行去重操作。

去重：在找到满足条件的三元组后，对 left 和 right 进行去重，避免结果中出现重复的三元组。同时，在遍历数组时，对第一个元素 a 也进行去重。

3.代码



class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        / 对数组进行排序
        Arrays.sort(nums);

        for (int i = 0; i < nums.length; i++) {
            / 如果当前数大于 0，由于数组有序，后续数都大于 0，不可能找到三数之和为 0 的组合
            if (nums[i] > 0) return res;
            / 去重，避免结果中出现重复的三元组
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }

            int left = i + 1;
            int right = nums.length - 1;
            while (right > left) {
                int sum = nums[i] + nums[left] + nums[right];
                if (sum > 0) {
                    right--;
                } else if (sum < 0) {
                    left++;
                } else {
                    / 找到满足条件的三元组
                    res.add(Arrays.asList(nums[i], nums[left], nums[right]));
                    / 对 left 去重
                    while (right > left && nums[left] == nums[left + 1]) {
                        left++;
                    }
                    / 对 right 去重
                    while (right > left && nums[right] == nums[right - 1]) {
                        right--;
                    }
                    / 移动指针继续寻找其他可能的组合
                    left++;
                    right--;
                }
            }
        }
        return res;
    }
}

四. 四数之和

1.题目链接

18. 四数之和 - 力扣（LeetCode）

2.思路

1. 排序操作
Arrays.sort(nums);  // 排序数组
排序操作是后续双指针法和去重操作的基础。排序后相同元素会相邻，方便去重，而且能利用双指针高效地寻找满足条件的组合。

2. 外层循环（固定第一个数）
for (int k = 0; k < nums.length; k++) {
    // 剪枝处理
    if (nums[k] > target && nums[k] >= 0) {
        break;	// 此处的break可以等价于return result;
    }
    // 对nums[k]去重
    if (k > 0 && nums[k] == nums[k - 1]) {
        continue;
    }
    // ...
}
剪枝处理：当 nums[k] > target 且 nums[k] >= 0 时，由于数组有序，后续元素只会更大，不可能再找到满足条件的四元组，所以可以提前结束循环。
去重操作：若当前元素和前一个元素相同，跳过当前元素，避免结果中出现重复的四元组。

3. 内层循环（固定第二个数）
for (int i = k + 1; i < nums.length; i++) {
    // 第二级剪枝
    if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {
        break;	// 注意是break到上一级for循环，如果直接return result;会有遗漏
    }
    // 对nums[i]去重
    if (i > k + 1 && nums[i] == nums[i - 1]) {
        continue;
    }
    // ...
}
第二级剪枝：当 nums[k] + nums[i] > target 且 nums[k] + nums[i] >= 0 时，同样由于数组有序，后续元素相加会更大，无法得到满足条件的四元组，所以提前结束当前内层循环。
去重操作：避免结果中出现重复的四元组。

4. 双指针法（寻找第三个数和第四个数）
int left = i + 1;
int right = nums.length - 1;
while (right > left) {
    long sum = (long) nums[k] + nums[i] + nums[left] + nums[right];
    if (sum > target) {
        right--;
    } else if (sum < target) {
        left++;
    } else {
        result.add(Arrays.asList(nums[k], nums[i], nums[left], nums[right]));
        // 对nums[left]和nums[right]去重
        while (right > left && nums[right] == nums[right - 1]) right--;
        while (right > left && nums[left] == nums[left + 1]) left++;
        right--;
        left++;
    }
}
类型转换：为了防止四个整数相加时出现溢出，将和的类型转换为 long。
双指针移动：若和大于目标值，右指针左移；若和小于目标值，左指针右移；若和等于目标值，将四元组添加到结果集，并对左右指针进行去重操作，然后移动指针继续寻找其他可能的组合。

3.代码

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