代码随想录算法Day7| 454.四数相加 II、383.赎金信、15.三数之和、18.四数之和

一、四数相加 II

力扣454

题目链接. - 力扣（LeetCode）

只统计有几个符合结果的四元组，不计较四元组是否重复。考虑使用hashmap存储前两个数组nums[i]与nums[j]之和sum = nums[i] + nums[j]，key为sum，value为取得该值的sum出现的次数。再计算后两个数组nums[k]与nums[l]之和，看是否等于-sum如果等于-sum则说明存在一个四元组。

时间复杂度: O(n^2)

空间复杂度: O(n^2)

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        // 将nums[i] + nums[j]的值存进map中
        for(int i : nums1){
            for(int j : nums2){
                int sum = i + j;
                //map.put(sum, map.get(sum) + 1)
                map.put(sum, map.getOrDefault(sum, 0) + 1);   
            }
        }

        int result = 0;
        //从map中找值为-(num3[i] + num[4])出现的次数
        for(int i : nums3){
            for(int j : nums4){
                int sum = -(i + j);
                result += map.getOrDefault(sum, 0);
            }
        }
        return result;
    }
}

二、赎金信

力扣383

题目链接. - 力扣（LeetCode）

首先判断ransomNote的长度，如果ransomNote的长度比magazine长的话那么ransomNote就无法由magazine一对一构成。然后将magzine的每个字母存到map中，key为magzine中的每个字符，value为该字符出现的次数。再遍历ransomNote，如果发现ransomNote中的字符在magzine中出现过，则令该字符(key)在magzine中对应的value值减一，如果对应的value值为0则说明magzine缺少该字符，返回false，这样在遍历完ransomNote后，返回true。

时间复杂度: O(n)

空间复杂度: O(1)

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        int[] alphabet = new int[26];
        //如果ransomNote的长度比magazine长的话那么ransomNote就无法由magazine一对一构成
        if(ransomNote.length() > magazine.length()){
            return false;
        }

        char[] magletter = magazine.toCharArray();
        for(int i = 0; i < magazine.length(); i++){
            int cha = magletter[i] - 'a';
            alphabet[cha] += 1;
        }

        char[] ranletter = ransomNote.toCharArray(); 
        for(int i = 0; i < ransomNote.length(); i++){
            int cha = ranletter[i] - 'a';
            if(alphabet[cha] > 0){
                alphabet[cha] -= 1;
            }else{
                return false;
            }
        }
        
        return true;

    }
}

三、三数之和

力扣15

题目链接. - 力扣（LeetCode）

双指针法，先对数组nums进行排序，然后遍历数组nums。取两个指针left = i+1、right = nums.length - 1，判断nums[i] + nums[left] + nums[right]的值与0的大小，如果大于0则令right--，否则令left++，注意在遍历过程中对i，j和k去重。

时间复杂度: O(n^2)

空间复杂度: O(1)

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        //排序
        Arrays.sort(nums);

        //排序之后如果第一个数大于0则无论如何都无法满足三元组之和等于0
        if(nums[0] > 0){
            return result;
        }
    
        Map<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i < nums.length; i++){
            //对i去重
            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]));
                    //对j和k去重
                    while(right > left && nums[right] == nums[right - 1]){
                        right--;
                    }
                    while(right > left && nums[left] == nums[left + 1]){
                        left++;
                    }
                    right--;
                    left++;
                }
            }


        }

        return result;

    }
}

四、四数之和

力扣18

题目链接. - 力扣（LeetCode）

与三数之和类似，要注意的一点是target可能是正也可能是负，只有当第一个数大于0且大于target的时候才会不满足四元数之和等于target,当target<0的时候直接开始计算即可。

时间复杂度: O(n^3)

空间复杂度: O(1)

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> result = new ArrayList<>();
        //排序
        Arrays.sort(nums);

        //注意,只有当第一个数大于0且大于target的时候才会不满足四元数之和等于target,当target<0的时候直接开始计算即可
        if(nums[0] > 0 && nums[0] > target){
            return result;
        }
    
        Map<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i < nums.length; i++){
            //对a去重
            if(i > 0 && nums[i] == nums[i-1]){
                continue;
            }
            
            for(int j = i + 1; j < nums.length; j++){
                //对b去重
                if(j > i + 1 && nums[j - 1] == nums [j]){
                    continue;
                }
                //双指针法
                int left = j + 1;
                int right = nums.length - 1;
                while(right > left){
                    long sum = (long)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]));
                        //对c和d去重
                        while(right > left && nums[right] == nums[right - 1]){
                            right--;
                        }
                        while(right > left && nums[left] == nums[left + 1]){
                            left++;
                        }
                        right--;
                        left++;
                    }
                }
            }
        }

        return result;
    }
}