代码随想录算法训练营第7天 | 454.四数相加II、 383. 赎金信、 15. 三数之和、18. 四数之和

454.四数相加II

题目：454.四数相加II
文档讲解：代码随想录-454.四数相加II
视频讲解：哔哩哔哩-454.四数相加II
状态/时间：没写出来/三十分钟

思路：
太神奇了，把两个数组先放在一起计算，然后就把两个数组计算的值放入到map当中，map的key为两个数字的和，value为这个和出现的次数,

再通过遍历后面两个数组的和，再0-他们的和，就是为了匹配前面map的key，例如： -5 + 5 = 0.

在这里就把count = count + val 加上，为啥不是++呢，因为它可以跟不一样的数组下标匹配。

最后把count返回就行了。

代码：

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {

        Map<Integer,Integer> map1 = new HashMap<Integer,Integer>();
        int sum;
        int val;
        int count = 0;
        int target;
        for (int num1 : nums1) {
            for (int num2 : nums2) {
                sum = num1 + num2;
                if (map1.containsKey(sum)) {
                    val = map1.get(sum);
                    val++;
                    map1.replace(sum,val);
                } else {
                    map1.put(sum, 1);
                }
            }
        }

        for (int num3 : nums3) {
            for (int num4 : nums4) {
                target = 0 - (num3 + num4);
                if (map1.containsKey(target)) {
                    int val2 = map1.get(target);
                    count = count + val2;
                }
            }
        }

        return count;
    }
}

注意：
分成两个部分进行计算，降低时间复杂度。

383. 赎金信

题目：383. 赎金信
文档讲解：代码随想录-383. 赎金信
视频讲解：哔哩哔哩-383. 赎金信
状态/时间：写出来了/十分钟

思路：
这道题跟有效的异位词很像，都是利用数组的下标来当字母的索引，例如设字母a的下标为0，字母b为1

然后数组存储的值为出现的次数

通过两次遍历计算之后，再遍历存储出现次数的数组。如果有一个值＜0，则表明无法从另外个数组复制，返回false，其他情况返回true。

下面的代码过于臃肿，可以参考卡哥的代码，更简洁。

代码：

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        if (ransomNote.length() > magazine.length()) {
            return false;
        }
        int hash[] = new int[26];
        char m[] = magazine.toCharArray();
        char r[] = ransomNote.toCharArray();

        for (int i = 0; i < magazine.length(); i++) {
            hash[m[i] - 'a']++;
        }

        for (int j = 0; j < ransomNote.length(); j++) {
            hash[r[j] - 'a']--;
        }
        for (int num : hash) {
            if (num < 0) {
                return false;
            }
        }
        return true;
    }
}

注意：
暂无

15. 三数之和

题目：15. 三数之和
文档讲解：代码随想录-15. 三数之和
视频讲解：哔哩哔哩-15. 三数之和
状态/时间：没写出来/三十分钟

思路：
先拿到数组的第一个数组，需要去重，因为题目规定了三个数字只能出现一次

再通过双指针进行判断后面两个数字的和，如果小于，就让左指针++；如果大于，则让右指针–。

发现三个数字之后等于0之后，就转换为数组返回即可。

之后再用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) {
                return res;
            }
            // 去重a
            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) {
                    left++;
                } else if (sum > 0) {
                    right --;
                } else {
                    res.add(Arrays.asList(nums[i], nums[left], nums[right]));
                    while (right > left && nums[left] == nums[left + 1]) {
                        left++;
                    }
                    while (right > left && nums[right] == nums[right - 1]) {
                         right--;
                    }
                    left++;
                    right--;
                }
            }
        }
        return res;
    }
}

注意：
最后的一步应当加入到res之后再进行移动左右指针

18. 四数之和

题目：18. 四数之和
文档讲解：代码随想录-18. 四数之和
视频讲解：哔哩哔哩-18. 四数之和
状态/时间：没写出来/四十分钟

思路：
就是在上面一题的基础上，再多加一个循环，但是这里要考虑到这是target，可能这个target是负数，特别考虑一下这点。

代码：

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(nums);
        // 遍历
        for (int k = 0; k < nums.length; k++) {
            // 剪枝处理
            if (nums[k] > target &&  nums[k] >= 0) {
                return res;
            }
            if (k > 0 && nums[k] == nums[k - 1]) {
                continue;
            }
            for (int i = k + 1; i < nums.length; i++) {
                // 二级剪枝
                if (nums[i] + nums[k] > target && nums[i] + nums[k] >= 0) {
                    break;
                }
                // 去重
                if (i > k + 1 && nums[i] == nums[i - 1]) {
                    continue;
                }
                // 注意设置指针的边界了
                int left = i + 1;
                int right = nums.length - 1;
                while (right > left) {
                    // int 会溢出
                    long sum = (long) nums[k] + nums[i] + nums[left] + nums[right];
                    if (sum > target) {
                        right--;
                    } else if (sum < target) {
                        left++;
                    } else {
                        res.add(Arrays.asList(nums[k], nums[i], nums[left], nums[right]));
                        while (right > left && nums[left] == nums[left + 1]) {
                            left++;
                        }
                        while (right > left && nums[right] == nums[right - 1]) {
                            right--;
                        }
                        left++;
                        right--;
                    }
                }
            }
        }
        return res;
    }
}

注意：

target可能是负数