代码随想录算法训练营Day07| 454. 四数相加Ⅱ 383.赎金信 15.三数之和 18.四数之和

454.四数相加Ⅱ

先看了视频，理解之后做出来的

var fourSumCount = function(nums1, nums2, nums3, nums4) {
    let map = new Map();
    for (let a = 0; a < nums1.length; a++) {
        for (let b = 0; b < nums2.length; b++) {

            let value = map.has(nums1[a] + nums2[b]) ? map.get(nums1[a] + nums2[b]) + 1 : 1;
            map.set(nums1[a] + nums2[b], value); //是否已有这个键，有则value+1，无则传入value为1；
        }
    }
    let count = 0; //用于储存，有多少个符合条件的元组  数量
    for (let c = 0; c < nums3.length; c++) {
        for (let d = 0; d < nums4.length; d++) {
            for (const [Key, value] of map.entries()) { //遍历并读取map中的键值对
                if (Key === -(nums3[c] + nums4[d])) {
                    count += value;
                }
            }
        }
    }
    return count;
};

注意：

1.map.entries() – returns an iterable for entries [key, value], it’s used by default in for..of.

2. 三元条件运算符中，不可以使用自增运算符（++），例如

 map.has(nums1[a] + nums2[b]) ? map.get(nums1[a] + nums2[b]) + + : 1; 2 // 是错误的 

不管是 前置（++map.get(nums1[a] + nums2[b])），还是后置（map.get(nums1[a] + nums2[b])++），因为三目条件运算符中没有其它运算，所以返回的依旧只是map.get(nums1[a] + nums2[b])的值，并无改变。

关于操作符前置和后置，不是什么情况下都可以用的，具体解释可以参考该篇文章：https://juejin.cn/post/7042101620380794917

383.赎金信

这题比较简单，思考步骤，以及代码如下:

/**
 * @param {string} ransomNote
 * @param {string} magazine
 * @return {boolean}
 */
var canConstruct = function(ransomNote, magazine) {
    let mapA = new Map();
    // 在mapA中存储ransomNote的所有字符，字符为key，出现次数为value；
    for (let letter of ransomNote) {
        if (mapA.has(letter)) {
            mapA.set(letter, mapA.get(letter) + 1);
        } else {
            mapA.set(letter, 1)
        }
    }
    // 遍历magazine，如果mapA中存在该字符，则对应的value-1
    for (let letter of magazine) {
        if (mapA.has(letter)) {
            mapA.set(letter, mapA.get(letter) - 1);
        }
    }
    // 遍历mapA，如果mapA中存在该字符的value > 0，则说明有字符不能由magazine中的字符构成，直接返回false
    for (const [key, value] of mapA.entries()) {
        if (value > 0) {
            return false;
        }
    }
    // 否则，返回true
    return true;
};

15.三数之和

先看视频，再自己做出来

方法：双指针法

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var threeSum = function(nums) {
    // 首先，进行排序
    //nums.sort();
    nums.sort((a, b) => a - b)
    let arr = new Array();
    for (let i = 0; i < nums.length; i++) {
        if (nums[i] > 0) return arr; //如果最小的数>0，则不可能有=0的三数之和，直接返回false
        if (i > 0 && nums[i] === nums[i - 1]) { continue; }
        let left = i + 1;
        let right = nums.length - 1;
        while (right > left) {
            if (nums[left] + nums[right] + nums[i] > 0) right--;
            else if (nums[left] + nums[right] + nums[i] < 0) left++;
            else {
                arr.push([nums[i], nums[left], nums[right]]);
                // 开始去重
                while (left < right && nums[left] === nums[left + 1]) {
                    left += 1;
                }
                while (left < right && nums[right] === nums[right - 1]) {
                    right -= 1;
                }
                // 双指针收缩
                right--;
                left++;
            }
        }
    }
    return arr;
};

18. 四数之和

先看了视频

注意以下几点：

1. 一级剪枝
   1. 　　

      if (nums[k] > target && (nums[k] > 0 || target >= 0)) break;
      //注意target 可能<0，若target<0，nums[k]>targert,而nums[k]+nums[k+1]<targer或=target 的可能是存在的！
      //故 补充条件：要么nums[k]>0 要么target>=0

2. 二级剪枝
   1. 　　 if (nums[k] + nums[i] > target && (nums[k] + nums[i] >= 0)) break; 2 // 注意此时是 nums[k] + nums[i] 作为整体与target比较

代码如下：

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[][]}
 */
var fourSum = function(nums, target) {
    nums.sort((a, b) => a - b)
    let arr = new Array();
    for (let k = 0; k < nums.length; k++) {
        // 一级剪枝处理
        if (nums[k] > target && (nums[k] > 0 || target >= 0)) break;
        // 对num[k]去重
        if (k > 0 && nums[k] === nums[k - 1]) continue;

        for (let i = k + 1; i < nums.length; i++) {
            // 二级剪枝
            if (nums[k] + nums[i] > target && (nums[k] + nums[i] >= 0)) break;
            // 对num[i]去重
            if (i > k + 1 && nums[i] === nums[i - 1]) continue;

            let left = i + 1;
            let right = nums.length - 1;

            while (left < right) {
                if (nums[i] + nums[k] + nums[left] + nums[right] > target) right--;
                else if (nums[i] + nums[k] + nums[left] + nums[right] < target) left++;
                else {
                    arr.push([nums[k], nums[i], nums[left], nums[right]]);

                    // 去重
                    while (left < right && nums[right] === nums[right - 1]) right--;
                    while (left < right && nums[left] === nums[left + 1]) left++;

                    // 双向收缩
                    left++;
                    right--;
                }
            }
        }
    }
    return arr;
};

收获

刷题顺利，开始喜欢上刷题了！