刷题第七天 | 454.四数相加II、383. 赎金信、15. 三数之和、18. 四数之和

454. 4Sum II

题目链接：454.四数相加II
思路链接：代码随想录哈希表-四数相加

思路

暴力解法：遍历四遍 Runtime: O(n^4)
map哈希表法：遍历前两个数组，构造map，key为两数组的任意两数之和，value为该两数之和总攻出现的次数。遍历后两个数组，得到任意的两数之和sum，在map中查找是否有0 - sum的key，若有，则在count上加相应的value数

心路历程

这道题一开始没思路，看了卡哥视频后，马上就实现了，代码不难，重在思路

Code

import java.util.Map;
import java.util.HashMap;

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        // 利用map哈希法 Runtime: O(n ^ 2)
        int count = 0;
        Map<Integer, Integer> map = new HashMap<>(); // key为两数字之和，value为遍历两数组时两数字之和出现的次数
        // 遍历前两个数组 O(n ^ 2)
        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);
                }
            }
        }
        // 遍历后两个数组，查找map是否存在0 - sum的key，若有count += map.get(key)
        for (int i : nums3) {
            for (int j : nums4) {
                if (map.containsKey(0 - (i + j))) {
                    count += map.get(0 - (i + j));
                }
            }
        }
        return count;
    }
}

383. Ransom Note

题目链接：383. 赎金信
思路链接：代码随想录哈希表-赎金信

思路

利用数组做哈希表，统计magazine中字母出现的个数，记录到哈希表上，然后遍历ransomNote，在哈希表上相应相减，最后遍历哈希表，如果有小于0的，则return false

心路历程

这题不难，自己做的

Code

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        int[] hash = new int[26];
        for (int i = 0; i < magazine.length(); i++) {
            hash[magazine.charAt(i) - 'a']++;
        }

        // for (int k : hash) {
        //     System.out.print(k);
        // }
        // System.out.println("");

        for (int j = 0; j < ransomNote.length(); j++) {
            hash[ransomNote.charAt(j) - 'a']--;
        }
        // for (int k : hash) {
        //     System.out.print(k);
        // }
        // System.out.println("");
        for (int k : hash) {
            if (k < 0) {
                return false;
            }
        }
        return true;
    }
}

15. 3Sum

题目链接：15. 三数之和
思路链接：代码随想录哈希表-三数之和

思路

双指针法：首先一定要先sort数组，先遍历数组确定三数中的第一个数，然后定义左右指针，如果三数之和大于0，则更新right；如果小于0，更新left；相等，加入result，并且更新指针。需要注意的是在for循环第一步需要加上对于第一个数的去重操作，条件为nums[i] == nums[i - 1]，这里必须用-，不能用+，否则会缺失三数结果。另外，对于left和right也要进行去重操作。

心路历程

这题有点复杂，注意点很多，尤其是去重操作，看了视频后，自己动手成功实现了，最近发现代码实现能力上来了

Code

import java.util.Arrays;
import java.util.ArrayList;

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        // 利用双指针法,前提是要先sort数组
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
        // 首先枚举第一个数，遍历数组
        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 (left < right) {
                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]));
                    // 对left, right去重
                    while (left < right && nums[left] == nums[left + 1]) {left++;}
                    while (left < right && nums[right] == nums[right - 1]) {right--;}
                    // 别忘记更新指针
                    left++;
                    right--;
                }
            }
        }
        return result;
    }
}

18. 4Sum

题目链接：18. 四数之和
思路链接：代码随想录哈希表-四数之和

思路

这题和15.三数之和的思路是一样的，无非就是多套了一层循环，但是更加复杂，注意点更多一些。在遍历确定第一个数时要有一级剪枝的操作，还要有去重操作；在遍历确定第二个数时要进行二级剪枝的操作外加去重，其他去15.三数之和是一样的。

心路历程

自己先动手操作了一下，对于去重的逻辑没想明白，然后去看了视频，就自己实现了，另外发现leetcode的debugger可以自己定义输入

Code

import java.util.ArrayList;
import java.util.Arrays;

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) {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) {break;}
                if (j > i + 1 && nums[j] == nums[j - 1]) {continue;}
                int left = j + 1;
                int right = nums.length - 1;
                while (left < right) {
                    int 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 (left < right && nums[left] == nums[left + 1]) {left++;}
                        while (left < right && nums[right] == nums[right - 1]) {right--;}
                        right--;
                        left++;
                    }
                }
            }
        }
        return result;
    }
}