代码随想录day6

哈希表 - 2

四数相加 ||

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

• 0 <= i, j, k, l < n
• nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

思路

我们可以将四个数组分成两部分，A 和 B为一组，C 和 D为另外一组。

对于 A 和 B，我们使用二重循环对它们进行遍历，得到所有 A[i]+B[j]的值并存入哈希映射中。对于哈希映射中的每个键值对，每个键表示一种 A[i]+B[j]，对应的值为 A[i]+B[j]出现的次数。

对于 C 和 D，我们同样使用二重循环对它们进行遍历。当遍历到 C[k]+D[l] 时，如果 −(C[k]+D[l])出现在哈希映射中，那么将 −(C[k]+D[l]) 对应的值累加进答案中。

class Solution {
    // 分组转换为两个数组
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        Map<Integer,Integer> map = new HashMap<>();
        for(int a : nums1){
            for(int b : nums2){
                map.put(a+b,map.getOrDefault(a+b,0) + 1);
            }
        }
        int res = 0;
        
        for(int c : nums3){
            for(int d : nums4){
                int sum = 0 - c - d;
                if(map.containsKey(sum)){
                    res += map.get(sum);
                }
            }
        }

        return res;
    }
}

赎金信

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。

思路

借助于map统计magazine 中每个字符的个数，然后再遍历ransomNote ，过程中是否出现map中不含有相应key的情况，以及value < 0的情况，若有直接返回false

class Solution {
    // 和字母异位次一样的解法
    public boolean canConstruct(String ransomNote, String magazine) {
        // map存储magazine里字符出现的次数
        Map<Character,Integer> map = new HashMap<>();
        for(int i = 0;i < magazine.length();i++){
            map.put(magazine.charAt(i),map.getOrDefault(magazine.charAt(i),0) + 1);
        }
        // 再遍历ransomNote，map中的value--,是否小于0
        for(int i =  0;i < ransomNote.length();i++){
            char c = ransomNote.charAt(i);
            if(!map.containsKey(c) || map.get(c) == 0)
                return false;
            map.put(c,map.get(c) - 1);
        }
        return true;
    }
}

三数之和

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请
你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

思路

使用哈希表难度加大，所以本题采用双指针思想
由于存储的是值不是数组下标，所以先对nums进行排序操作

一层for循环，i从下标0的地方开始，同时定一个下标left 定义在i+1的位置上，定义下标right 在数组结尾的位置上。

依然还是在数组中找到 abc 使得a + b +c =0，我们这里相当于 a = nums[i]，b = nums[left]，c = nums[right]。

接下来如何移动left 和right呢， 如果nums[i] + nums[left] + nums[right] > 0 就说明 此时三数之和大了，因为数组是排序后了，所以right下标就应该向左移动，这样才能让三数之和小一些。

如果 nums[i] + nums[left] + nums[right] < 0 说明 此时 三数之和小了，left 就向右移动，才能让三数之和大一些，直到left与right相遇为止。

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 - 2;i++){
            if(nums[i] > 0)
                break; // 后续都不满足
            List<Integer> tmp = new ArrayList<>();
            // 注意去重
            if(i > 0 && nums[i] == nums[i - 1])
                continue;

            // 双指针
            int l = i + 1;
            int r = nums.length - 1;
            while(l < r){

                int sum = nums[i] + nums[l] + nums[r];

                if(sum == 0){
                    res.add(Arrays.asList(nums[i],nums[l],nums[r]));
                    // 内部去重
                    while(l < r && nums[l] == nums[l + 1]) l++;
                    while(l < r && nums[r] == nums[r - 1]) r--;
                    l++;
                    r--;
                }else if(sum < 0) l++;
                else r--;
            }

        }
        return res;

    }
}

四数之和

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

• 0 <= a, b, c, d < n
• a、b、c 和 d 互不相同
• nums[a] + nums[b] + nums[c] + nums[d] == target

你可以按 任意顺序 返回答案 。

思路

这道题和三数之和的解决思路是一样的，只需要在外层再加一层for循环

注意细节：剪枝操作，target可能为负数，所以在剪枝时需考虑 target 是否大于0
双层for循环，进行两次剪枝以及去重

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(nums);
        for (int i = 0; i < nums.length - 3; i++) {
            // 剪枝
            if (nums[i] > target && (nums[i] > 0 || target > 0))
                break;
            // 去重
            if (i > 0 && nums[i] == nums[i - 1])
                continue;
            for (int j = i + 1; j < nums.length - 2; j++) {
                // 继续剪枝
                if (nums[i] + nums[j] > target && nums[i] + nums[j] > 0)
                    break;

                // 去重
                if (j > i + 1 && nums[j] == nums[j - 1])
                    continue;

                int l = j + 1;
                int r = nums.length - 1;

                while (l < r) {
                    long sum = nums[i] + nums[j] + nums[l] + nums[r];
                    if (sum == target) {
                        res.add(Arrays.asList(nums[i], nums[j], nums[l], nums[r]));
                        // 内部去重
                        while (l < r && nums[l] == nums[l + 1])
                            l++;
                        while (l < r && nums[r] == nums[r - 1])
                            r--;
                        l++;
                        r--;
                    } else if (sum > target)
                        r--;
                    else
                        l++;
                }
            }
        }
        return res;
    }
}