哈希表2|454.四数相加II|383.赎金信|15. 三数之和|18.四数之和

哈希表2|454.四数相加II|383.赎金信|15. 三数之和|18.四数之和

一、四数相加II

题目连接：454. 四数相加 II - 力扣（LeetCode）

1. 思路：将nums1+nums2的值存入集合中，key记录其求和的值，value记录该值有几个。遍历nums3和nums4数组，判断nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0，如果存在，则将该一组值存入集合。
2. 注意：计算多少个元组时，不是count+1，是count += value.

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int count = 0;
        Map<Integer,Integer> map = new HashMap<>();
        for(int i : nums1){
            for(int j : nums2){
                if(map.containsKey(i + j)){
                    map.put(i + j, map.get(i+j)+1);
                }else {
                    map.put(i + j,1);
                }
            }
        }
        for(int i : nums3){
            for(int j : nums4){
                int target = 0 - (i + j);
                if(map.containsKey(target)){
                    count += map.get(target);
                }
            }
        }
        return count;
    }
}

二、383.赎金信

题目连接：383. 赎金信 - 力扣（LeetCode）

1. 这题和有效的字母异位词那题差不多，可以用数组解决。
2. 字符串转数组用.toCharArray()方法

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

三、15. 三数之和

题目连接：15. 三数之和 - 力扣（LeetCode）

1. 三元组之和为0，题目要求不重复，用哈希法的话去重比较复杂，这里采用双指针法。
2. 思路：先对数组进行升序排列，遍历数组，i 指针指向当前位置，left指向下一位，right指向数组最后一位。当nums[i] + nums[left] + nums[right] < 0时，说明还需要增大，left右移一位；当nums[i] + nums[left] + nums[right] > 0时,说明还需要减小，right左移一位。
3. 剪枝：如果第一个元素 > 0，因为数组是升序的，说明三个数相加一定 > 0
4. 元素去重：是判断 nums[i] 与 nums[i + 1]是否相同，还是判断 nums[i] 与 nums[i-1] 是否相同 ，是看当前 i 指针是需要和自己前面还是后面的元素比较。第一个元素 i 是需要和自己的前一个元素比较，相同则说明本次循环得出得结果重复了，应该跳过，故应和 nums[i-1]比较。第二个元素当前是在left，是需要看下一个位置元素是否相同，所以是和nums[left + 1]比较。right与left同理，但right的下一个元素是nums[right - 1]。

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 left = i + 1;
            int right = nums.length - 1;
            while(left < right){
                if(nums[i] + nums[left] + nums[right] > 0){
                    right--;
                }else if(nums[i] + nums[left] + nums[right] < 0){
                    left++;
                }else{
                    List<Integer> re = new ArrayList<>();
                    re.add(nums[i]);re.add(nums[left]);re.add(nums[right]);
                    result.add(re);
                    //对第二个元素去重
                    while(right > left && nums[left] == nums[left + 1]) left++;
                    //对第三个元素去重
                    while(right > left && nums[right] == nums[right - 1]) right--;
                    left++;right--;
                }
            }
        }
        return result;
    }
}

四、18.四数之和

题目连接：18. 四数之和 - 力扣（LeetCode）

1. 此题大体思路和三数之和一致，只是需要多一层循环和去重，去重思想和三数之和题一样。
2. 剪枝：与三数之和不同的是，四数之和这道题目 target是任意值 ，剪枝的时候需要注意条件，虽然数组是升序排列的，nums[k] > target 不一定就四数之和 > target，因为负数+负数会变小，只有正数 + 正数 会变大。故判断条件为 nums[k] > target && nums[k] >= 0.

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
        for(int k = 0; k < nums.length; k++){
            if(nums[k] > target && nums[k] >= 0) break;//剪枝
            if(k > 0 && nums[k] == nums[k - 1]) continue;//去重
            for(int i = k + 1; i < nums.length; i++){
                if(nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) break;//剪枝
                if(i > k + 1 && nums[i] == nums[i - 1]) continue;//去重
                int left = i + 1;
                int right = nums.length - 1;
                while(left < right){
                    int sum = nums[k] + nums[i] + nums[left] + nums[right];
                    if(sum > target){
                        right--;
                    }else if(sum < target){
                        left++;
                    }else {
                        result.add(Arrays.asList(nums[k],nums[i],nums[left],nums[right]));
                        while(left < right && nums[left] == nums[left + 1]) left++;//去重
                        while(left < right && nums[right] == nums[right - 1]) right--;//去重
                        right--;left++;
                    }
                }
            }
        }
        return result;
    }
}