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

LeetCode：454. 四数相加 II - 力扣（LeetCode）

//getOrDefault是Java编程语言中的一种方法，用于从Map中检索与指定键关联的值。如果Map中不存在该键，则该方法返回一个默认值。方法签名如下：

 思路：这道题和之前的两数相加很像，大体思路就是用map集合存对应的key和value，这次key是两个数组之和，value是出现这个和的次数，我原本想的获取value后出现次数转换成int型，下一个负数数组也是这样，到时返回两个累计的乘积值。

　　不过卡哥代码是用来一个上边那个函数，有的话就返回1，这样就可以直接累加，特别好。还是基础比较薄弱，这些方法我都没见过、、。。。

 public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int res = 0;
        //两两配对，将a+b的值和次数存到map里 key：a+b value :出现次数
            Map<Integer,Integer> record = new HashMap<>();
            for (int i : nums1){
                for(int j : nums2){
                    int sum = i + j;
                    record.put(sum,record.getOrDefault(sum,0)+1);
                }
            }
            //同上，这个是去找对应record的负值，这样才能满足a+b+c+d == 0;
            for (int i : nums3){
                for (int j : nums4){
                    res+= record.getOrDefault(0-i-j,0);
                }
            }
            return res;
    }

LeetCode：383. 赎金信 - 力扣（LeetCode）

第一时间思路：感觉还行啊，这题可以用map集合，key是二十六个字母，value是出现的次数，一个个判断呗，有就加，没有就减。最后和第二个去比较，a的value一样不，如果value大于等于不就成立，但凡有一个小于不就不成立了。看看视频再继续。

思路：上边没有问题，就是基础有点忘了

//toCharArray是Java编程语言中用于将字符串转换为字符数组的方法。该方法的签名如下：

public boolean canConstruct(String ransomNote, String magazine) {
        int[] ary = new int[26];

        for (char i : ransomNote.toCharArray()){
            ary[i-'a']-=1;
        }
        for (char i : magazine.toCharArray()){
            ary[i-'a']+=1;
        }
        for(int i :ary){
            if(i < 0){
                return  false;
            }

        }
        return true;
    }

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

去重，数组不熟悉，基础，方法

思路：和两数之和差不多，这个双指针的思路很nb，

拿这个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相遇为止。

 

public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> List = new ArrayList<>();

        //从小到大
        Arrays.sort(nums);

        for( int i = 0; i < nums.length; i++){
            int left = i + 1,right = nums.length-1;
            //说明最大的数都是正数，不可能等于零了
            if ( nums[i] > 0){
                return  List;
            }
            // 判断去重
            if( i > 0 && nums[i] == nums[i-1]){
                continue;
            }
            //三种情况
            //多
            while(right > left){
                int sum = nums[i] + nums[left] + nums[right];
                if( sum > 0){
                    right--;
                }
                //少
                if( sum < 0){
                    left++;
                }
                //0 存储元组
                if( sum == 0){
                    List.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--;

                    }
                    left++;
                    right--;

            }


            }



        }
        return List;
    }

 

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

思路：

四数之和，和15.三数之和 (opens new window)是一个思路，都是使用双指针法, 基本解法就是在15.三数之和 (opens new window)的基础上再套一层for循环。

但是有一些细节需要注意，例如： 不要判断nums[k] > target 就返回了，三数之和 可以通过 nums[i] > 0 就返回了，因为 0 已经是确定的数了，四数之和这道题目 target是任意值。比如：数组是[-4, -3, -2, -1]，target是-10，不能因为-4 > -10而跳过。但是我们依旧可以去做剪枝，逻辑变成nums[i] > target && (nums[i] >=0 || target >= 0)就可以了。

public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> List = new ArrayList<>();

        //从小到大
        Arrays.sort(nums);

        for(int j = 0;j < nums.length;j++){
            //第一步剪枝
            if(nums[j] > 0 && nums[j] > target){
                return List;
            }
            //第一步去重
            if( j > 0 && nums[j - 1] == nums[j]){
                continue;
            }
            for( int i = j + 1; i < nums.length; i++){
                if( i > j + 1 && nums[i - 1] == nums[i]){
                    continue;
                }
                int left = i + 1,right = nums.length-1;
                //说明最大的数都是正数，不可能等于零了
                /*卧槽
                if ( nums[i] > 0){
                    return  List;
                }
                *\
                 */
                // 判断去重

                //三种情况
                //多
                while(right > left){
                    long sum = (long) nums[i] + nums[left] + nums[right] + nums[j];
                    if( sum > target){
                        right--;
                    }
                    //少
                    if( sum < target){
                        left++;
                    }
                    //0 存储元组
                    if( sum == target){
                        List.add(Arrays.asList(nums[j],nums[i],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 List;
    }