代码随想录算法训练营第七天| LeetCode454.四数相加II、Leetcode383. 赎金信、Leetcode15. 三数之和、Leetcode18. 四数之和 。

454.四数相加II

题目链接：454.四数相加II

这道题目是四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不用考虑有重复的四个元素相加等于0的情况，所以相对于题目15.三数之和，题目18. 四数之和，还是相对简单的。

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
    int result = 0;
    Map<Integer,Integer> map = new HashMap<>();
    //统计两个数组中的元素之和，同时统计出现的次数
    //key:元素之和 value:次数
    for(int i:nums1){
        for(int j:nums2){
            int sum = i+j;
            map.put(sum,map.getOrDefault(sum,0)+1);
        }
    }
    //统计剩余两个元素的和
    for(int i:nums3){
        for(int j:nums4){
            int temp =i+j;
            result+=map.getOrDefault(0-temp,0);
        }
    }
    return result;
    }
}

383. 赎金信

题目链接：383. 赎金信

这道题目和242.有效的字母异位词 (opens new window)很像，242.有效的字母异位词 (opens new window)相当于求 字符串a和字符串b是否可以相互组成 ，而这道题目是求字符串a能否组成字符串b，而不用管字符串b能不能组成字符串a。

本题使用map的空间消耗要比数组大一些的，因为map要维护红黑树或者哈希表，而且还要做哈希函数，是费时的！数据量大的话就能体现出来差别了。 所以数组更加简单直接有效！

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        if (ransomNote.length() > magazine.length()) {
            return false;
        }
        // 定义一个哈希映射数组
        int[] record = new int[26];

        // 遍历
        for(char c : magazine.toCharArray()){
            record[c - 'a'] += 1;
        }

        for(char c : ransomNote.toCharArray()){
            record[c - 'a'] -= 1;
        }
        
        // 如果数组中存在负数，说明ransomNote字符串总存在magazine中没有的字符
        for(int i : record){
            if(i < 0){
                return false;
            }
        }

        return true;
    }
}

15. 三数之和

题目链接：15. 三数之和

两层for循环就可以确定 a 和b 的数值了，可以使用哈希法来确定 0-(a+b) 是否在 数组里出现过，其实这个思路是正确的，但是我们有一个非常棘手的问题，就是题目中说的不可以包含重复的三元组。把符合条件的三元组放进vector中，然后再去重，这样是非常费时的。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        //返回值，可以对数据进行排序
        Arrays.sort(nums); 
        // 找出a + b + c = 0
        // a = nums[i], b = nums[left], c = nums[right]
        // 排序之后如果第一个元素已经大于零，
        //那么无论如何组合都不可能凑成三元组，直接返回结果就可以了
        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]));
                    // 去重逻辑应该放在找到一个三元组之后，对b 和 c去重
                    while(right>left&&nums[right]==nums[right-1]){
                        right--;
                    }
                    while(right>left&&nums[left]==nums[left+1]){
                        left++;
                    }
                    right--;
                    left++;
                }
            }
        }
        return result;
    } 
}

18. 四数之和

题目链接：18. 四数之和

对于15.三数之和 (opens new window)双指针法就是将原本暴力O(n3)的解法，降为O(n2)的解法，四数之和的双指针解法就是将原本暴力O(n4)的解法，降为O(n3)的解法。

双指针法将时间复杂度：O(n^2)的解法优化为 O(n)的解法。也就是降一个数量级，题目如下：

数组相关双指针题目：
27.移除元素(opens new window)
15.三数之和(opens new window)
18.四数之和(opens new window)

链表相关双指针题目：
206.反转链表(opens new window)
19.删除链表的倒数第N个节点(opens new window)
面试题 02.07. 链表相交(opens new window)
142题.环形链表II

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++){
            /**
            注意:
            例如： 不要判断nums[i] > target 就返回了，三数之和可以通过 nums[i] > 0 就返回了，
            因为 0 已经是确定的数了，四数之和这道题目 target是任意值。
            比如：数组是[-4, -3, -2, -1]，target是-10，不能因为-4 > -10而跳过。
            但是我们依旧可以去做剪枝，对正数进行剪枝，
            逻辑变成nums[i] > target && (nums[i] >=0 || target >= 0)就可以了。 
            */
            if(nums[i]>0&&nums[i]>target){
                return result;
            }

            if(i>0&&nums[i-1]==nums[i]){
                continue;
            }

            for(int j=i+1;j<nums.length;j++){
                if(j>i+1&&nums[j-1]==nums[j]){
                    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;
    }
}