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

代码随想录算法训练营第七天（补卡）

因为这几天在赶稿小论文，就每天系统的刷题，这个习惯不太好，要改正，一定要合理规划时间

代码随想录

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

示例 1：

输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2

因为之前做过，有印象，第一次尝试的是暴力法，但是超出时间限制。

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int count = 0;
        for(int i = 0;i<nums1.length;i++){
            for(int j = 0;j<nums2.length;j++){
                for(int k = 0;k<nums3.length;k++){
                    for(int l = 0;l<nums4.length;l++){
                        if(nums1[i]+nums2[j]+nums3[k]+nums4[l]==0){
                            count++;
                        }
                    }
                }
            }
        }
        return count;
}
}

想要了用map，先让前两个数组中元素相加，记录map中key为“和”，value为出现次数，然后判断map中是否有后两个数组相加的元素，如果有计数+1.

public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int sum = 0;
        int count = 0;
        Map<Integer,Integer> map  = new HashMap<>();
        for(int i :nums1){
            for(int j:nums2){
                sum = i+j;
                //这里value传入计数 在map中查询sum,若没有则为计数1，若有则+1
                map.put(sum,map.getOrDefault(sum,0)+1);
            }
        }
        for(int k :nums3){
            for(int l : nums4){
                count += map.getOrDefault(0-k-l,0);
            }
        }
        
        return count;
    }

383. 赎金信

给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。

(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)

注意：

你可以假设两个字符串均只含有小写字母。

canConstruct(“a”, “b”) -> false
canConstruct(“aa”, “ab”) -> false
canConstruct(“aa”, “aab”) -> true

思路

暴力法：遍历两个数组，若找到相同字符，则在赎金信 (ransom) 中删除这个字符，最后赎金信 (ransom) 中元素长度为0，则ransom 可以由magazines 里面的字符构成。

public boolean canConstruct(String ransomNote, String magazine) {
        char[] ransomNoteChars = ransomNote.toCharArray();
        char[] magazineChars = magazine.toCharArray();

        if(ransomNote==null||ransomNote.length()==0){
            return true;
        }
        for(int i =0;i<magazineChars.length;i++){
            for(int j = 0;j<ransomNoteChars.length;j++){
                if(ransomNoteChars[j]== magazineChars[i]){
                    // 使用 '\0' 表示删除这个字符
                    ransomNoteChars[j] ='\0';
                    break;
                }
            }
        }
        // 如果ransomNote中的所有字符都被找到并删除，则说明magazine的字符可以组成ransomNote
        for(char c : ransomNoteChars){
            if(c!='\0'){
                return false;
            }
        }

        return true;
    }

因为两个字符串均只含有小写字母。想到了用数组

public boolean canConstruct(String ransomNote, String magazine) {
        int[] res = new int[26];
        if(ransomNote==null||ransomNote.length()==0){
            return true;
        }
        if(ransomNote.length()>magazine.length()){
            return false;
        }
        for(char i:magazine.toCharArray()){
            res[i-'a']+=1;
        }
        for(char j:ransomNote.toCharArray()){
            res[j-'a']-=1;
        }
		// 若数组中元素存在负数，则ransomNote中一定有杂志中没有的元素
        for(int i :res){
            if(i<0){
                return false;
            }
        }

        return true;
    }

15. 三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

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

示例：

给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]

解法1. 两层for循环就可以确定 a 和b 的数值了，可以使用哈希法来确定 0-(a+b) 是否在 数组里出现过，但是去重比较麻烦。

思路：选择双指针，首先将数组排序，然后有一层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相遇为止。至少收获一个

去重a , 判断 nums[i] == nums [i-1] ,要与上一个判断，符合条件的结果再去去重b、c if nums[right] == num [right-1] right--; if nums[left] == num [left+1] left++

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

        for(int i = 0 ;i<nums.length;i++){
            if(nums[i]>0){
                return res;
            }
            //去重a
            if(i>0&& nums[i]==nums[i-1]){
                continue;
            }
            int left = i+1;
            int right = nums.length-1;

            while (left<right){
                if (nums[i]+nums[left]+nums[right]>0){
                    right--;
                }
                else if (nums[i]+nums[left]+nums[right]<0){
                    left++;
                }
                else{
                    res.add(Arrays.asList(nums[i],nums[left],nums[right]));
                    while(right>left && nums[left]==nums[left+1]){
                        left++;
                    }
                    while (right>left && nums[right]==nums[right-1]){
                        right--;
                    }
                    right--;
                    left++;
                }
            }

        }
        return res;
    }

18. 四数之和

题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

注意：

答案中不可以包含重复的四元组。

示例： 给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。 满足要求的四元组集合为： [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]

思路：因为刚做了三数之和，所有想到了加一层循环还是采用双指针的方式，但是剪枝条件没有判断好，使用了三数之和的剪枝，没有考虑负数的情况。

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++){
        	// 注意  数组是[-4, -3, -2, -1]，target是-10，不能因为-4 > -10而跳过。
            if (nums[i] > 0 && nums[i] > target) {
                return result;
            }

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

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