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

454. 四数相加II

这道题是四个独立的数组，不用考虑有重复的四个元素相加等于0的情况，不需要考虑去重的情况。

本题解题步骤：

1. 首先定义 一个map，key放a和b两数之和，value 放a和b两数之和出现的次数。
2. 遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中。
3. 定义count，用来统计 a+b+c+d = 0 出现的次数。
4. 在遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。
5. 最后返回统计值 count。

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @param {number[]} nums3
 * @param {number[]} nums4
 * @return {number}
 */
var fourSumCount = function(nums1, nums2, nums3, nums4) {
    let map = new Map();
    let result = 0;
    for(const n1 of nums1){
        for(const n2 of nums2){
            const sum = n1 + n2;
            map.set(sum, (map.get(sum) || 0) + 1);
        }
    }
    for(const n3 of nums3){
        for(const n4 of nums4){
            const target = 0 - (n3 + n4);
            result += (map.get(target) || 0);
        }
    }
    return result;
};

383. 赎金信

这道题和 242. 有效字母异位词 很像，而这道题目是求 字符串a能否组成字符串b，而不用管字符串b 能不能组成字符串a。

由于说明只有小写字母，还是可以用一个长度为26的数组记录magazine里字母出现的次数。然后再用ransomNote去验证这个数组是否包含了ransomNote所需要的所有字母。

/**
 * @param {string} ransomNote
 * @param {string} magazine
 * @return {boolean}
 */
var canConstruct = function(ransomNote, magazine) {
    const strArr = new Array(26).fill(0), 
        base = "a".charCodeAt();
    for(const s of magazine) {  // 记录 magazine里各个字符出现次数
        strArr[s.charCodeAt() - base]++;
    }
    for(const s of ransomNote) { // 对应的字符个数做--操作
        const index = s.charCodeAt() - base;
        if(!strArr[index]) return false;
        strArr[index]--;
    }
    return true;
};

15. 三数之和

双指针法：首先将数组排序，然后有一层for循环，i从下标0的地方开始，同时定一个下标left 定义在i+1的位置上，定义下标right 在数组结尾的位置上。接下来，如果nums[i] + nums[left] + nums[right] > 0 就说明 此时三数之和大了，因为数组是排序后了，所以right下标就应该向左移动，这样才能让三数之和小一些。left同理。

去重：这是本题的难点。

• nums[i] 的去重：a是nums里遍历的元素，如果重复了那么应该直接跳过去。其次是要判断判断 nums[i] 与 nums[i-1] 是否相同，而不是nums[i] 与 nums[i + 1]是否相同。我们要做的是 不能有重复的三元组，但三元组内的元素是可以重复的。
• nums[left] 和 nums[right] 的去重：例如如果nums[right] === nums[right-1]说明遍历到right-1时会遇到相同的三元组，所以提前多进行一次right–。

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var threeSum = function (nums) {
    let result = [], len = nums.length;
    nums.sort((a, b) => a - b);
    for (let i = 0; i < len; i++) {
        let left = i + 1, right = len - 1, iNum = nums[i];
        // 数组排过序，如果第一个元素大于0直接返回res
        if (iNum > 0) return result;
        // 去重
        if (iNum == nums[i - 1]) continue;
        while (left < right) {
            let lNum = nums[left], rNum = nums[right], threeSum = iNum + lNum + rNum;
            // 三数之和小于0， 左指针向右移动
            if (threeSum < 0) left++;
            else if (threeSum > 0) right--;
            else {
                result.push([iNum, lNum, rNum]);
                //去重
                while(left < right && nums[left] === nums[left + 1]){
                    left++;
                }
                while(left < right && nums[right] === nums[right - 1]){
                    right--;
                }
                left++;
                right--;
            }
        }
    }
    return result;
}

18.四数之和

和三数之和是同样的方法，只不过需要在最外层加一层for循环。重点仍是对四个索引的去重操作。

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[][]}
 */
var fourSum = function (nums, target) {
    const len = nums.length;
    if (len < 4) return [];
    let result = [];
    nums.sort((a, b) => a - b);
    for (let i = 0; i < len - 3; i++) {
        //去重i
        if (i > 0 && nums[i] === nums[i - 1]) continue;
        for (let j = i + 1; j < len - 2; j++) {
            //去重j
            if (j > i + 1 && nums[j] === nums[j - 1]) continue;
            let left = j + 1, right = len - 1;
            while (right > left) {
                let sum = nums[i] + nums[j] + nums[left] + nums[right];
                if (sum < target) {
                    left++;
                    continue;
                }
                if (sum > target) {
                    right--;
                    continue;
                }
                else {
                    result.push([nums[i], nums[j], nums[left], nums[right]]);
                }
                //去重nums[left]和nums[right]
                while (left < right && nums[left] === nums[++left]);
                while (left < right && nums[right] === nums[--right]);
            }
        }
    }
    return result;
};

哈希表篇总结

一般来说哈希表都是用来快速判断一个元素是否出现集合里。

1. 数组作为哈希表：数组的大小是受限的！map的空间消耗要比数组大一些，因为map要维护红黑树或者符号表，而且还要做哈希函数的运算。所以数组更加简单直接有效！
2. set作为哈希表：没有限制数值的大小就不能用数组做哈希表了。Set只存储键，没有value，且没有重复的key。
3. map作为哈希表：map可以用key保存数值，用value在保存数值所在的下标；或者用key来保存数值，用value保存数值出现的次数。可灵活变通！
4. 双指针法：需要去重时考虑用双指针，哈希法去重导致代码效率很低且很难！