代码随想录day07

一、四数相加||（LeetCode454）

首先定义int变量cot，用来统计a+b+c+d=0出现的次数,再次定义一个HashMap，key放a和b两数之和，value 放a和b两数之和出现的次数。
遍历nums1和nums2数组，统计两个数组元素之和，和出现的次数，放到map中。
在遍历nums3和nums4数组，找到如果0-(c+d)在map中出现过的话，就用cot把map中key对应的value也就是出现次数统计出来。最后返回统计值 cot 

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int cot = 0;
        Map<Integer,Integer> map = new HashMap<>();
        //统计两个数组中的元素之和，同时统计出现的次数，放入map
        for(int a : nums1){
            for(int b : nums2){
                if(map.containsKey(a+b)){
                    map.put(a+b,map.get(a+b)+1);
                }else{
                    map.put(a+b,1);
                }
                // map.put(a+b,1);
                // if(map.containsKey(a+b)){
                //     map.put(a+b,map.get(a+b++));
                // }
            }
        }
        //统计剩余的两个元素的和，在map中找是否存在相加为0的情况，同时记录次数
        for(int c : nums3){
            for(int d : nums4){
                if(map.containsKey(0-(c+d))){
                    cot += map.get(0-(c+d));
                }
            }
        }
        return cot;
    }
}

二、赎金信（LeetCode383）

题目和有效的字母异位词(LeetCode242)很像，使用哈希映射数组，之后遍历统计计数所出现的字母，另一字符遍历查找并减数，最后遍历哈希数组，若存在负数则说明查找的字符中不存在这样的字符。

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        int[] res = new int[26]; // 定义一个哈希映射数组
        //遍历
        for(int j = 0;j < magazine.length();j++){
            res[magazine.charAt(j) - 'a']++;
        }
        for(int i = 0;i < ransomNote.length();i++){
            res[ransomNote.charAt(i) - 'a']--;
        }
        for(int c : res){
            if(c < 0){ //如果数组中存在负数，说明ransomNote字符串存在magazine中没有的字符
                return false;
            }
        }
        return true;
    }
}

三、三数之和（LeetCode15）

双指针：定义list集合用来存放结果，首先要对原数组进行sort排序，之后进行遍历；若第一个元素>0直接结束，否则对其去重(从i>0判断i和i-1);定义左指针(i+1)和右指针(nums.length-1),while(right>left)循环判断三个数的和，若>0则右指针左移，若<0则左指针右移，若为0则结果放入list集合(add(Arrays.asList())),之后while循环去重另两个值，最后左右指针同时收缩。

class Solution {
    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){
                break;
            }
            if(i > 0 && nums[i] == nums[i-1]){ //去重a
                continue;
            }
            int left = i+1;
            int right = nums.length-1;
            while(right > left){
                if(nums[i] + nums[left] + nums[right] > 0){
                    right--;
                }else if(nums[i] + nums[left] + nums[right] < 0){
                    left++;
                }else{
                    //Arrays.asList()方法将一个数组转换为一个List集合
                    res.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 res;
    }
}

四、四数之和（LeetCode18）

和三数之和类似，要比三数多一层for循环，以及去重和二次剪枝要改动，之后进行双指针操作

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res =new ArrayList<>();
        Arrays.sort(nums);
        for(int i  = 0;i < nums.length;i++){
            //剪枝
            if(nums[i] > target && (nums[i] >= 0 || target >= 0)){
                break;
            }
            //去重
            if(i > 0 && nums[i] == nums[i-1]){
                continue;
            }
            for(int j = i+1;j < nums.length;j++){
                //剪枝
                if(nums[i]+nums[j] > target && (nums[i]+nums[j] >= 0 || target >= 0)){
                    break;
                }
                //去重
                if(j > i+1 && nums[j] == nums[j-1]){
                    continue;
                }
                int left = j+1;
                int right = nums.length-1;
                while(right > left){
                    //int会溢出
                    if((long)(nums[i] + nums[j] + nums[left] + nums[right]) > target){
                        right--;
                    }else if((long)(nums[i] + nums[j] + nums[left] + nums[right]) < target){
                        left++;
                    }else{
                        res.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 res;
    }
}