第七天| 454.四数相加II ，383.赎金信 ，15.三数之和 ，18.四数之和

第七天| 454.四数相加II ，383.赎金信 ，15.三数之和 ，18.四数之和

/**
 * 2024/1/2 第七天 T1
 * 454.四数相加II
 */
public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        HashMap<Integer, Integer> map = new HashMap<>();
        int res = 0;
        for (int i : nums1){
            for (int j : nums2){
                int sum = i + j;
                map.put(sum, map.getOrDefault(sum,0) + 1);
            }
        }
        for (int i : nums3){
            for (int j : nums4){
                res += map.getOrDefault(0 - i - j,0);
            }
        }
        return res;
    }

• 暴力o(n^4), 使用hash方式o(n^2)
• 使用hash法中的Map方式，A B C D四个数组，先将数组A B的元素两两组合的和所有情况存到Map的key中，value表示相同和的情况有多少种。然后 C D两个数组遍历所有和的情况并去Map中找对应的key 即 0 - i - j 是否存在，存在就将情况累加到res。注意到map.getOrDefault(0 - i - j,0) 的使用。
• Hash相关的操作一般有三种处理方式: 数组 Set Map

/**
 * 2024/1/2 第七天 T2
 * 383.赎金信
 */
public boolean canConstruct(String ransomNote, String magazine) {
        if (ransomNote.length() > magazine.length()) return false;
        int[] ans = new int[28];
        for (int i = 0; i < ransomNote.length(); i++) ans[ransomNote.charAt(i) - 'a']++;
        for (int i = 0; i < magazine.length(); i++) ans[magazine.charAt(i) - 'a']--;
        for (int j = 0; j < 26; j++){
            if (ans[j] > 0){
                return false;
            }
        }
        return true;
    }
242.有效的字母异位词

• ac
• 直接使用hash法中的数组方式，类似242.有效的字母异位词
• Hash相关的操作一般有三种处理方式: 数组 Set Map

/**
 * 2024/1/2 第七天 T3
 * 15.三数之和
 */
public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> lists = new ArrayList<>();
        Arrays.sort(nums);//排序
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > 0) return lists; //nums[i] > 0,说明和一定不等于0,该行代码可以省去很多不必判断的情况,大大提升了效率。
            if(i > 0 && nums[i] == nums[i - 1]) continue; //a去重
            int l = i + 1;
            int r = nums.length - 1;
            while (l < r){
                int sum = nums[i] + nums[l] + nums[r];
                if (sum < 0){
                    l++;
                } else if(sum > 0){
                    r--;
                } else { //等于0,即满足条件时 需要记录该情况，并对b和c进行去重。
                    ArrayList list = new ArrayList();
                    list.add(nums[i]);
                    list.add(nums[l]);
                    list.add(nums[r]);
                    lists.add(list);
                    while (l < r && nums[l] == nums[l + 1]) l++;//b去重 先获取一个结果再去重 0 0 0 0 防止这种情况最后直接pass掉！！！
                    while (l < r && nums[r] == nums[r - 1]) r--;//c去重
                    l++;//跳到内部未遍历的区间
                    r--;
                }
            }
        }
        return lists;
    }

• 太难啦。。
• 思路：排序 + 双指针，细节是a b c三个数的去重。if (nums[i] > 0) return lists; //nums[i] > 0,说明和一定不等于0,该行代码可以省去很多不必判断的情况,大大提升了效率。
• 三数之和 使用排序 +双指针的解法 相对于Map的解法更好理解，2h。

/**
 * 2024/1/2 第七天 T4
 * 18.四数之和
 */
public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> lists = new ArrayList<>();
        Arrays.sort(nums);//先排序

        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > 0 && nums[i] > target) return lists;//剪枝 a > 0 且大于target 必然没有和等于target的情况，直接返回（降低时间复杂度）。
            if (i > 0 && nums[i] == nums[i - 1]) continue; //a去重
            for (int j = i + 1; j < nums.length; j++) {
                if (j > i + 1 && nums[j] == nums[j - 1]) continue; //b去重
                int l = j + 1;
                int r = nums.length - 1;
                while(l < r){
                    // int sum = nums[i] + nums[j] + nums[l] + nums[r]; //小坑！！！ int会溢出!!!
                    long sum = (long) nums[i] + nums[j] + nums[l] + nums[r];
                    if (sum > target){
                        r--;
                    } else if (sum < target){
                        l++;
                    } else { //sum == target 满足条件时 需要先记录该该情况,然后对b和c进行去重。
                        ArrayList<Integer> list = new ArrayList<>();
                        list.add(nums[i]);
                        list.add(nums[j]);
                        list.add(nums[l]);
                        list.add(nums[r]);
                        lists.add(list);
                        while (l < r && nums[l] == nums[l + 1]) l++; //c去重
                        while (l < r && nums[r] == nums[r - 1]) r--; //d去重
                        l++;//跳到内部未遍历的区间
                        r--;
                    }
                }
            }
        }
        return lists;
    }

• 四数之和 与 三数之和 解法一样，只是外面嵌套了两层for循环。
• 思路：与三数之和方法一样。需要注意到 a b c d的去重，sum可能溢出int的范围，剪枝的条件判断。
• 四数之和 同样使用排序 +双指针的解法 ，1h。