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

题解思路参见
代码随想录

四数相加II

思路

题解思路：定义好返回值为count。分成AB和CD两部分，遍历AB，将AB的和以及出现次数保存到map中，将和作为map的key，将次数作为map的value。接着遍历CD，如果-CD的和在map中存在，那么计数+1.
另外对于java来说需要考虑key不存在的情况时的初始值，可以调用map类中的getOrDefault(key,如果不存在整个key的默认值)方法。

代码：

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {

    int count = 0;
    Map<Integer,Integer> sumMap = new HashMap<Integer,Integer>();
    for(int i = 0;i<nums1.length;i++){
        for(int j = 0;j<nums2.length;j++){
            sumMap.put(nums1[i]+nums2[j],sumMap.getOrDefault(nums1[i]+nums2[j],0)+1); 
        }
    }

    for(int i = 0;i<nums3.length;i++){
        for(int j = 0;j<nums4.length;j++){
            
            count += sumMap.getOrDefault(-nums3[i]-nums4[j],0); 
        }
    }

    return count;
    }
}

赎金信

思路

思路：跟字母异位次类似，定义一个26大小的数组，统计每个字符在magazine里出现的次数，然后遍历ransomNote，减去出现的字母，如果最后数组中没有小于0的数，那么则返回true。注意字母的ascii码转换，需要减去‘a‘表示相对的大小。

代码

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

        for(int i = 0;i<magazine.length();i++){
            count[magazine.charAt(i)-'a']++;
        }

        for(int i = 0; i < ransomNote.length();i++){
            count[ransomNote.charAt(i)-'a']--;
        }

        for(int i = 0;i<count.length;i++){
            if(count[i]<0) return false;
        }

        return true;
    }
}

题解思路：额外考虑剪支操作，每次进入函数后，先考虑空或者极端的特殊情况，如果不满足立刻退出，这样就不用执行后面的代码，节约时间。

if (ransomNote.length() > magazine.length()) {
            return false;
        }

三数之和

思路

题解思路：这次比较难，因为要返回的是所有不重复的三元组，所以需要定义一个二维的list，第一维度存储个数，第二维度存储每组符合条件的三元组。
不可以重复，于是用排序的方法先对数组排序，然后使用三个指针，来控制移动。
大循环控制第一个数，内部循环控制后面两个数，保证能够遍历所有的数组元素。且如果大循环的本次数字=上次数字，直接continue，保证第1、2个数字不重复。内部循环left<right，保证2、3个数字不重复。

代码

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {

        List<List<Integer>> lists = new ArrayList<>();
        Arrays.sort(nums);

        int len = nums.length;

        int left = 0;
        int right = len - 1;
        

        for (int i = 0; i<len - 2 ; i++){
            left = i+1;
            right = len - 1;
            if(nums[i]>0){
                break;
            }

            if(i > 0 && nums[i] == nums[i-1]) continue;
            while(left<right){
                int temp = nums[i]+nums[left]+nums[right];

                if(temp==0){
                    List<Integer> list = new ArrayList<>();
                    list.add(nums[i]);
                    list.add(nums[left]);
                    list.add(nums[right]);
                    lists.add(list);
                    while(left < right && nums[left+1] == nums[left]) ++left;
                    while (left < right && nums[right-1] == nums[right]) --right;
                    right--;
                    left++;
                    
                }else if(temp>0){
                    right--;
                }else{
                    left++;
                }
            }
           
        }

        return lists;

    }
}

四数之和

思路

思路：跟三数之和思路一样，在三数之和的基础上再加一层循环。仍然使用双指针法，指向数组下标。
时间复杂度变成O（n^3）

代码

出错的：

class Solution {
    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-3;i++){
            if(nums[i]>target){
                break;
            }
            if(i>0 && nums[i]==nums[i-1]) continue;

            for(int j = i+1;j<nums.length-2;j++){
                
                if(j>i+1 && nums[j]==nums[j-1]) 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){
                        right--;
                    }else if(sum < target){
                        left++;
                    }else{
                        lists.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 lists;

    }
}

问题分析：
上述代码有错是因为，数组中的元素可能是负数，在第一个循环里剪支的时候，不能nums[i]>target就退出，因为下一个数字可能还是负数，仍然有变小的可能，所以只有当第一个数字是正数，且大于target，才需要剪支

if(nums[i] > 0 && nums[i]>target){
                break;
            }