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

 1 454. 四数相加 II

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

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

 提示：

• n == nums1.length
• n == nums2.length
• n == nums3.length
• n == nums4.length
• 1 <= n <= 200
• -228 <= nums1[i], nums2[i], nums3[i], nums4[i] <= 228

思路： 本题采用哈希表的思路解决。四个数组两两一组，降低时间复杂度。首先遍历数组a,b，将a+b的和生成unorderedMap，key值记录和的值，value记录和出现的次数。然后遍历数组c,d，当前表中存在满足 0-(c+d) 的元素，证明有元素能满足题意，count对应增加。

注意：count对应增加value的值。

Java实现

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int res = 0;
        Map<Integer,Integer> map = new HashMap<Integer,Integer>();
        //统计前两个数组中元素和及出现次数
        for(int i:nums1){
            for(int j:nums2){
                int sum = i + j;
                map.put(sum,map.getOrDefault(sum,0)+1);

            }
        }

        //统计后两个数组和并匹配是否有和为零的情况
        for(int k:nums3){
            for(int l:nums4){
                res += map.getOrDefault(0-k-l,0);
            }
        }
        return res;
    }
}

2 383. 赎金信

题目：给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。如果可以，返回 true ；否则返回 false 。magazine 中的每个字符只能在 ransomNote 中使用一次。

提示：

• 1 <= ransomNote.length, magazine.length <= 105
• ransomNote 和 magazine 由小写英文字母组成

思路：本题可理解为是否存在元素，且保证出现次数。考虑到只由小写英文字母组成，元素个数明确，因此采用数组实现哈希表。数组下标表示字母位置，元素值表示magazine中字母出现的次数。首先遍历magazine数组，生成字母元素集合，然后遍历ransomNote数组，当出现某个元素时，在magazine对应的表中-1，当元素值小于0时，证明生成失败。

Java实现

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        if(ransomNote.length()>magazine.length()){
            return false;
        }
        // 定义映射数组，全为小写因此数组大小为26
        int[] record = new int[26];
        for(char c:magazine.toCharArray()){
            record[c-'a'] += 1;
        }
        for(char c:ransomNote.toCharArray()){
            record[c-'a'] -= 1;
        }

        // 检查元素出现次数是否满足要求
        for(int i:record){
            if(i<0)
                return false;
        }
        return true;
    }
}

3 15. 三数之和

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

提示：

• 3 <= nums.length <= 3000
• -105 <= nums[i] <= 105

思路：本题同第一题不同，本题要求在一个数组中找到三个不同的元素组成的集合满足和为零，且元素不重复。采用暴力法也可解决，时间复杂度为O(n^3)。考虑到本题只需输出元素组合，不用输出元素下标，因此考虑使用双指针法解决。

首先将数组升序，从头开始遍历【a】。此时当第一个元素大于零时，证明该数组不存在符合要求的元素集合，可直接结束。若小于零时，遍历元素向后设置为左指针【b】，尾元素设置为右指针【c】。根据三个元素和的大小，调整左右指针的位置。 

本题另一重点在于元素去重，但是博主没有完全吃透，建议大家去看卡尔哥的讲解。

注意：去重去重去重！只输出元素集合，不考虑元素原下标。

Java实现

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        // 双指针法
        List<List<Integer>> result = new ArrayList<>();
        // 双指针法需要排序，不需要输出下标可以排序
        Arrays.sort(nums);

        for(int i = 0;i<nums.length;i++){
            if(nums[i]>0){
                return result;
            }
            
            // 对a去重
            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{
                    result.add(Arrays.asList(nums[i],nums[left],nums[right]));
                    
                    // 对c去重
                    while(right>left && nums[right]==nums[right-1])
                        right--;
                    
                    // 对b去重
                    while(right>left && nums[left]==nums[left+1])
                        left++;
                    right--;
                    left++;
                }

            }
        }
        return result;
    }
}

4 18. 四数之和

题目： 给你一个由 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

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

提示：

• 1 <= nums.length <= 200
• -109 <= nums[i] <= 109
• -109 <= target <= 109

思路：同上，就是多嵌套一层。

Java实现

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]>0 && nums[i]>target) // 去掉nums[i]>0 条件部分样例不通过，原因？
                return result;
            // 对a去重
            if(i>0 && nums[i]==nums[i-1]){
                continue;
            }

            for(int j=i+1;j<nums.length;j++){
                if(j>i+1 && nums[j]==nums[j-1]){
                    continue;
                }

                int left= j+1;
                int right = nums.length-1;
                while(right>left){
                    long 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[right]==nums[right-1])
                            right--;
                        while(right>left && nums[left]==nums[left+1])
                            left++;

                        right--;
                        left++;
                    }

                }
            }
        }
        return result;
    }
}