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

454. 四数相加 II

将四个数组分为两组：A、B和C、D。
首先用两层for循环记算A、B两数组中各取一个元素相加的所有结果 i + j，并存入hashMap中，key为元素的结果，value为这个结果出现的次数。
然后再用两层for循环计算C、D两数组中各取一个元素相加的所有结果 k + l，要使i+j+k+l=0，那么i+j就要等于-(k+l)，所以我们在map中查找key=-(k+l)的value即可，所有满足条件的value相加，就是题目的答案了。

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int res = 0;
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        for(int i : nums1){         
            for(int j : nums2){
                int sum = i + j;    //计算前两个数组各元素相加能得到的所有结果
                map.put(sum, map.getOrDefault(sum, 0) + 1);     //分别记录所有结果出现的次数
            }
        }
        for(int k : nums3){
            for(int l : nums4){     //计算后两个数组中各元素相加的所有结果
                res += map.getOrDefault(0 - (k + l), 0);    //i+j+k+l=0,i+j=0-(k+l),所以我们在遍历后两个数组元素相加的所有结果时，在map中查找key=0-(k+l)的值即可 
            }
        }
        return res;
    }
}

383. 赎金信

暴力法

遍历ransomNote的每个字符，然后获取magazine中此字符的下标，如果存在，就将此字符从magazine中删去，如果不存在，也就是说magazine中的字符无法组成ransomNote，返回false。
需要注意的是，magazine是String类型，不可变，所以我们要将它转化为StringBuilder类型才可以修改字符串。

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        if (ransomNote.length() > magazine.length()) {
            return false;
        }
        StringBuilder sb = new StringBuilder(magazine);
        for(int i = 0; i < ransomNote.length(); i++){
            int index = sb.indexOf(String.valueOf(ransomNote.charAt(i)));	//获取当前循环中
            if(index != -1){
                sb.deleteCharAt(index);
            }else{
                return false;
            }
        }
        return true;
    }
}

哈希法

定义一个26个元素的哈希数组，遍历ransomNote字符串，记录不同字符的出现次数，然后再遍历magazine字符串，从哈希数组中减去对应字符的出现次数。如果最后哈希数组中有大于0的元素，说明这个元素代表的字符没有被消耗完，就返回false，否则返回true。

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        if(ransomNote.length() > magazine.length()){
            return false;
        }
        int[] record = new int[26];
        for(int i = 0; i < ransomNote.length(); i++){
            record[ransomNote.charAt(i) - 'a']++;
        }
        for(int i = 0; i < magazine.length(); i++){
            record[magazine.charAt(i) - 'a']--;
        }
        for(int i : record){
            if(i > 0){
                return false;
            }
        }
        return true;
    }
}

15. 三数之和

两数之和：梦开始的地方
三数之和：梦碎的地方

哈希法

两层for循环来确定a和b的值，并记录在map中，然后遍历第三个数组，确定-(a+b)有没有在数组中出现过。但这种方法去重非常麻烦，有很多要考虑的地方，后续补充

双指针法

先对数组排序，然后使用for循环遍历数组，确定a的值。接下来在[a+1,nums.length-1]使用双指针，分别从左右两侧向中间移动，来寻找a+b+c=0的组合。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
        for(int i = 0; i < nums.length; i++){
            if(nums[i] > 0){
                return result;
            }
            if(i > 0 && nums[i] == nums[i - 1]){
                continue;
            }
            int j = i + 1;
            int k = nums.length - 1;
            while(j < k){
                if(nums[i] + nums[k] + nums[j] > 0){
                    k--;
                }else if(nums[i] + nums[k] + nums[j] < 0){
                    j++;
                }else{
                    result.add(Arrays.asList(nums[i], nums[j], nums[k]));
                    while(j < k && nums[j] == nums[j + 1]){
                        j++;
                    }
                    while(j < k && nums[k] == nums[k - 1]){
                        k--;
                    }
                    j++;
                    k--;
                }
            }
        }
        return result;
    }
}

18. 四数之和

四数之和就是在三数之和的基础上再加一层for循环。双指针法的意义就在于它可以把暴力法O(n⁴)的时间复杂度降到O(n³)

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++){
            if(nums[i] > 0 && nums[i] > target){
                return result;
            }
            if(i > 0 && nums[i] == nums[i - 1]){
                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(left < right){
                    if(nums[i] + nums[j] + nums[left] + nums[right] > target){
                        right--;
                    }else if (nums[i] + nums[j] + nums[left] + nums[right] < target){
                        left++;
                    }else {
                        result.add(Arrays.asList(nums[i],nums[j],nums[left],nums[right]));
                        while(left < right && nums[right] == nums[right-1]){
                            right--;
                        }
                        while(left < right && nums[left] == nums[left+1]){
                            left++;
                        }
                        right--;
                        left++;
                    }
                }
            }
        }
        return result;
    }
}