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

454. 四数相加 II

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

解题：将四个数组两两分组，并统计两边的组里面能统计的和的数量，并记录在一个map里面，然后遍历另一个组的和，根据计算，获取第一个组的和数量，在result内输出

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @param {number[]} nums3
 * @param {number[]} nums4
 * @return {number}
 */
var fourSumCount = function(nums1, nums2, nums3, nums4) {
    let sumMap = {}
    let result = 0
    for(const i of nums1) {
        for(const j of nums2) {
            let sum = i + j
            if(sumMap[sum]) {
                sumMap[sum]++
            } else {
                sumMap[sum] = 1
            }
        }
    }
    for(const i of nums3) {
        for(const j of nums4) {
            let sum = 0 - (i + j)
            if (sumMap[sum]) {
                result += sumMap[sum]
            }
        }
    }
    return result
};

383. 赎金信

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。如果可以，返回 true ；否则返回 false 。magazine 中的每个字符只能在 ransomNote 中使用一次。

解题：本题和之前的字母异位词有点相似，开辟一个26位的数组用来存放每个字母出现过的次数，然后在遍历第一个字符上做--，并统计返回结果

注意：这里前端必须要调用charCodeAt() 方法才能转换成可减的数字，并将a.charCodeAt() 作为base值

/**
 * @param {string} ransomNote
 * @param {string} magazine
 * @return {boolean}
 */
var canConstruct = function(ransomNote, magazine) {
    let mapA = new Array(26).fill(0)
    let base = 'a'.charCodeAt()
    for(let i = 0; i<magazine.length;i++) {
        let index = magazine[i].charCodeAt() - base
        mapA[index]++
    }
    for(let i = 0; i<ransomNote.length;i++) {
        let index = ransomNote[i].charCodeAt() - base
        if (mapA[index] <= 0) {
            return false
        }
        mapA[index]--
    }
    return true
};

15. 三数之和

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。注意：答案中不可以包含重复的三元组。

解题：这里的思路其实是双指针，将for循环第一个值，然后设置left和right值，当小于或者大于时做left++或right--，这里要注意的是如何去重，第一个值的去重是将它和前一个值作比较，left和right的去重是要判断重复后，持续地 -- 或 ++，最后再做一次left++

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var threeSum = function(nums) {
    let numMap = nums.sort((a, b) => a - b)
    let result = []
    for(let i = 0;i<numMap.length;i++) {
        if (numMap[i] > 0) {
            return result
        }
        if (i > 0 && numMap[i] === numMap[i-1]) {
            continue;
        }
        let left = i + 1, right = numMap.length - 1;
        while(left < right) {
            let sum = numMap[i] + numMap[left] + numMap[right]
            if (sum > 0) {
                right--
            } else if (sum < 0) {
                left++
            } else {
                result.push([numMap[i], numMap[left], numMap[right]])
                while(left < right) {
                    left++
                    if (numMap[left] === numMap[left - 1]) {
                        continue;
                    } else {
                        break;
                    }
                }
            }
        }
    }
    return result
};

18. 四数之和

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

0 <= a, b, c, d < n  a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target你可以按 任意顺序 返回答案 

解题：四数之和与三数之和的思路是相似的，多一个数就要在外层多套一层for循环，并且要注意，最外层的判断去重和截止的时候，不能直接判断numMap[j] > target，因为这个target值有可能是负数，必须加上一个numMap[j] > 0，才能完成判断（在这里卡了用例，调试比较久

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