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

前端花卷

已于 2023-12-15 10:46:05 修改

阅读量111

点赞数 1

分类专栏：代码随想录算法训练营文章标签：哈希表算法数据结构 javascript

于 2023-09-14 18:01:05 首次发布

本文链接：https://blog.csdn.net/weixin_61498310/article/details/132867110

版权

代码随想录算法训练营专栏收录该内容

19 篇文章 0 订阅

订阅专栏

454. 四数相加 II

题目

力扣题目链接

视频讲解（代码随想录）

给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。

为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -2^28 到 2^28 - 1 之间，最终结果不会超过 2^31 - 1 。

例如:

输入:

A = [ 1, 2]
B = [-2,-1]
C = [-1, 2]
D = [ 0, 2]

输出:

解释:

两个元组如下:

(0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
(1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0

思路

本题解题步骤：

首先定义一个unordered_map，key放a和b两数之和，value 放n1和n2两数之和出现的次数。
遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中。
定义int变量count，用来统计 n1+n2+n3+n4= 0 出现的次数。
在遍历大C和大D数组，找到如果 0-(n3+n4) 在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。
最后返回统计值 count 就可以了

代码如下（JavaScript）

var fourSumCount = function(nums1, nums2, nums3, nums4) {
  //定义一个map，key放n1和n2两数之和，value 放n1和n2两数之和出现的次数
   const twoSumMap=new Map()
   let count=0
   //遍历数组nums1和nums2,将对应的n1和n2相加得到sum
   for(const n1 of nums1){
     for(const n2 of nums2){
       let sum =n1+n2
       //twoSumMap.get(sum) 表示获取sum之前在map中出现的次数，如果之前出现了，就在原有数量基础之上+1，如果获取不到，则表示之前还没有该值，则直接0+1。
       //然后将sum存放入map的key中，将出现的数量存放在value中
       twoSumMap.set(sum,(twoSumMap.get(sum)||0)+1)
     }
   }
   //遍历数组nums3和nums4,将对应的n3和n4相加得到sum
   for (const n3 of nums3){
     for(const n4 of nums4){
       let sum =n3+n4
       //如果 0-(n3+n4) 在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。
       count+=(twoSumMap.get(0-sum)||0)
     }
   }
  //  最后返回统计值 count 
   return count

};

383. 赎金信

题目

力扣题目链接

给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。

(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)

注意：

你可以假设两个字符串均只含有小写字母。

canConstruct("a", "b") -> false
canConstruct("aa", "ab") -> false
canConstruct("aa", "aab") -> true

思路

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

本题判断第一个字符串ransom能不能由第二个字符串magazines里面的字符构成，但是这里需要注意两点。

第一点“为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思” 这里说明杂志里面的字母不可重复使用。
第二点 “你可以假设两个字符串均只含有小写字母。” 说明只有小写字母，这一点很重要

哈希解法

因为题目说只有小写字母，那可以采用空间换取时间的哈希策略，用一个长度为26的数组来记录magazine里字母出现的次数。

然后再用ransomNote去验证这个数组是否包含了ransomNote所需要的所有字母。

依然是数组在哈希法中的应用。

代码如下（JavaScript）

var canConstruct = function(ransomNote, magazine) {
  //先定义一个数组，初始化为0
  const strArr=new Array(26).fill(0)
  const base ="a".charCodeAt()
  //遍历magazine，并在数组里记录magazine中字母出现的次数
  for(const s of magazine){
    strArr[s.charCodeAt()-base]++
  }
  //遍历ransomNote
  for(const s of ransomNote){
    const index=s.charCodeAt()-base
    //如果ransomNote所需的字母在strArr中没有，则直接返回false
    if(!strArr[index]) return false
    //如果ransomNote所需的字母在strArr中找到，则让strArr对应的字母（元素）下标-1，然后进入下一个循环
    strArr[index]--
  }
  //最后当ransomNote所需的字母都找到的话，结果返回true
  return true
};

15.三数之和

题目

力扣题目链接

视频讲解（代码随享录）

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

注意： 答案中不可以包含重复的三元组。

示例：

给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]

思路

双指针法

动画效果如下：

拿这个nums数组来举例，首先将数组排序，然后有一层for循环，i从下标0的地方开始，同时定一个下标left 定义在i+1的位置上，定义下标right 在数组结尾的位置上。

依然还是在数组中找到 abc 使得a + b +c =0，我们这里相当于 a = nums[i]，b = nums[left]，c = nums[right]。

接下来如何移动left 和right呢，如果nums[i] + nums[left] + nums[right] > 0 就说明此时三数之和大了，因为数组是排序后了，所以right下标就应该向左移动，这样才能让三数之和小一些。

如果 nums[i] + nums[left] + nums[right] < 0 说明此时三数之和小了，left 就向右移动，才能让三数之和大一些，直到left与right相遇为止。

时间复杂度：O(n^2)。

去重逻辑的思考

a的去重

说到去重，其实主要考虑三个数的去重。 a, b ,c, 对应的就是 nums[i]，nums[left]，nums[right]

a 如果重复了怎么办，a是nums里遍历的元素，那么应该直接跳过去。

但这里有一个问题，是判断 nums[i] 与 nums[i + 1]是否相同，还是判断 nums[i] 与 nums[i-1] 是否相同。

有同学可能想，这不都一样吗。

其实不一样！

都是和 nums[i]进行比较，是比较它的前一个，还是比较它的后一个。

如果我们的写法是这样：

if (nums[i] == nums[i + 1]) { // 去重操作
    continue;
}

那我们就把三元组中出现重复元素的情况直接pass掉了。例如{-1, -1 ,2} 这组数据，当遍历到第一个-1 的时候，判断下一个也是-1，那这组数据就pass了。

我们要做的是不能有重复的三元组，但三元组内的元素是可以重复的！

所以这里是有两个重复的维度。

那么应该这么写：

if (i > 0 && nums[i] == nums[i - 1]) {
    continue;
}

这么写就是当前使用 nums[i]，我们判断前一位是不是一样的元素，在看 {-1, -1 ,2} 这组数据，当遍历到第一个 -1 的时候，只要前一位没有-1，那么 {-1, -1 ,2} 这组数据一样可以收录到结果集里。

这是一个非常细节的思考过程。

b与c的去重

很多同学写本题的时候，去重的逻辑多加了对right 和left 的去重：（代码中注释部分）

while (right > left) {
    if (nums[i] + nums[left] + nums[right] > 0) {
        right--;
        // 去重 right
        while (left < right && nums[right] == nums[right + 1]) right--;
    } else if (nums[i] + nums[left] + nums[right] < 0) {
        left++;
        // 去重 left
        while (left < right && nums[left] == nums[left - 1]) left++;
    } else {
    }
}

但细想一下，这种去重其实对提升程序运行效率是没有帮助的。

拿right去重为例，即使不加这个去重逻辑，依然根据 while (right > left) 和 if (nums[i] + nums[left] + nums[right] > 0) 去完成right-- 的操作。

多加了 while (left < right && nums[right] == nums[right + 1]) right--; 这一行代码，其实就是把需要执行的逻辑提前执行了，但并没有减少判断的逻辑。

最直白的思考过程，就是right还是一个数一个数的减下去的，所以在哪里减的都是一样的。

所以这种去重是可以不加的。仅仅是把去重的逻辑提前了而已。

代码如下（JavaScript）

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

18.四数之和

力扣题目链接

视频讲解（代码随享录）

四数之和，和15.三数之和一个思路，都是使用双指针法, 基本解法就是在15.三数之和基础上再套一层for循环。

但是有一些细节需要注意，例如：不要判断nums[k] > target 就返回了，三数之和可以通过 nums[i] > 0 就返回了，因为 0 已经是确定的数了，四数之和这道题目 target是任意值。比如：数组是[-4, -3, -2, -1]，target是-10，不能因为-4 > -10而跳过。但是我们依旧可以去做剪枝，逻辑变成nums[i] > target && (nums[i] >=0 || target >= 0)就可以了。

15.三数之和双指针解法是一层for循环num[i]为确定值，然后循环内有left和right下标作为双指针，找到nums[i] + nums[left] + nums[right] == 0。

四数之和的双指针解法是两层for循环nums[k] + nums[i]为确定值，依然是循环内有left和right下标作为双指针，找出nums[k] + nums[i] + nums[left] + nums[right] == target的情况，三数之和的时间复杂度是O(n^2)，四数之和的时间复杂度是O(n^3) 。

那么一样的道理，五数之和、六数之和等等都采用这种解法。

代码如下（JavaScript)

var fourSum = function(nums, target) {
    const len = nums.length;
    if(len < 4) return [];
    nums.sort((a, b) => a - b);
    const res = [];
    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 l = j + 1, r = len - 1;
            while(l < r) {
                const sum = nums[i] + nums[j] + nums[l] + nums[r];
                if(sum < target) { l++; continue}
                if(sum > target) { r--; continue}
                res.push([nums[i], nums[j], nums[l], nums[r]]);
		
		// 对nums[left]和nums[right]去重
                while(l < r && nums[l] === nums[++l]);
                while(l < r && nums[r] === nums[--r]);
            }
        } 
    }
    return res;
};