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

最新推荐文章于 2024-09-12 19:02:20 发布

幺幺绛

最新推荐文章于 2024-09-12 19:02:20 发布

阅读量870

点赞数 19

文章标签：算法数据结构哈希表

本文链接：https://blog.csdn.net/weixin_51871394/article/details/135957540

版权

454.四数之和II

题目：力扣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

思路：

回顾之前之前的二数之和，是在一个数组中寻找是否存在和为target的两个数，采用的是哈希表的map，map用来记录已经遍历过的元素，遍历数组，在map中看是否能找到(target-当前数)

这道题不仅要统计是否出现过，还要统计出现的次数，所以用map。map的key存出现过的，value统计出现次数（一定要弄清各自分工，开始就是没弄清，那个两数之和的value不是用来存下标了么，结果我刚刚就一直把value当成下标看了，弄得我迷迷糊糊）在map中，键值key通常用于排序和惟一地标识元素，而值value中存储与此键值key关联的内容。四个数组，两两分析，因为效率更好（我也没想到，暴力四个for肯定太复杂，是O（n4)，然后就想着先处理一个，再剩下三个但这样是O（n3），咋就没想两两处理呢，哎）。

遍历前两个数组，统计两个数组元素之和，和出现的次数，放到map中。

遍历后两个数组，统计两个数组元素之和放在一个数组中

res用来统计个数，在map中寻找 -两元素之和，找到之后 res加上map中value的值

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        //定义map,用来存放num1,nums2每两个数的和
        unordered_map<int, int> m;
        vector<int> sum34(nums3.size()*nums4.size());
        int res = 0;
        //循环将依次遍历 nums1 中的每个元素，
        //将当前元素的值赋给 num1，然后执行循环体内的代码块
        for (int num1 : nums1) {
            for (int num2 : nums2) {
                m[num1 + num2]++;
            }
        }
        int index = 0; // 添加索引变量
        for (int i = 0; i < nums3.size(); i++) {
            for (int j = 0; j < nums4.size(); j++) {
                sum34[index] = nums3[i] + nums4[j];
                index++; // 更新索引值
            }
        }
        for (int num : sum34) {
            //如果在m中找到了当前的-sum34的值
            if (m.find(-num) != m.end()) {
                //统计出现次数
                res+=m[-num];
            }
        }
        return res;
    }
};

注意：map的key存出现过，value存出现次数

在map中找的是 -(c+d)（a+b+c+d=0)

res每次不是+1，而是加map中value的值（比如a+b有三种情况为7，当c+d=-7时，a+b+c+d=0也就是三种）

383.赎金信

题目：力扣383.赎金信

讲解：代码随想录

题目描述：

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。

思路：和异位词差不多，区别在于长度不等一定不是异位词，但长度不等却可以满足本题，比如aa,aab。字符串ransomNote中有的，字符串magazine 中肯定也有，但是magazine 中还可以有除此之外的字符

异位词中，一加一减统计字母出现次数的数组，最后只要结果不等于0就不是

本题中同样也一加一减，如果数组中存在大于0的就说明不符题意

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        //ransomeNote里的字符在magazine中都能找到
        if (magazine.length() < ransomNote.length()) {
            return false;
        }
        //定义数组
        vector<int> hash(26);
        //统计字符串中字母出现的次数，并存储在数组 hash 中
        for (int i = 0; i < ransomNote.length(); i++) {
            hash[ransomNote[i] - 'a']++;
        }
        for (int j = 0; j < magazine.length(); j++) {
            hash[magazine[j] - 'a']--;
        }
        for (int k = 0; k < hash.size(); k++) {
            //如果数组中有大于0的数，说明magzine中缺少对应的字符
            if (hash[k] > 0) {
                return  false;
            }
        }
        return true;
    }
};

15.三数之和

题目：力扣15.三数之和

讲解：代码随想录

题目描述：

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

你返回所有和为 0 且不重复的三元组。

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

思路：题目已经告诉不能有重复三元组，这也是这道题的重难点，也是我不会的....

有做过求两数之和用哈希法做的，这道题很容易想到哈希，但是如果用哈希，一个for找a，一个for找b，在哈希表寻找0-a-b,不推荐用哈希的原因就是用哈希找的时候时没有顺序的，导致去重很麻烦

考虑双指针的想法，一个for循环i遍历数组找a,left指向当前值下一位，right指向末尾，注意要给数组先从小到大排个序（引入#include<algorithm>），可以排序的原因是，本题要求返回的三元组是元素值，与下标无关，为什么要排序是因为，当前遍历前i是固定的，如果a+b+c>0,这时候和要变小才可能等于0，变小就让right--（因为是从小到大排好序的），同理，如果a+b+c<0,这时候和要变大，那么让left++

去重：

#include<vector>
#include<algorithm>
using namespace std;
class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        //定义存放结果的二维数组
        vector<vector<int>> res;
        //对数组从小到大排序
        sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size(); i++) {
            // 排序之后如果第一个元素已经大于零，那么不可能凑成三元组
            if (nums[i] > 0) {
                break;
            }
            //别忘记要保证i->=0，并且这条要放在&&前面
            if (i>0 && nums[i] == nums[i - 1]) {
                //对a去重
                continue;
            }
            int left = i + 1;
            int right = nums.size() - 1;
            //left right向中间移动
            while (left < right) {
                if (nums[i] + nums[left] + nums[right] < 0) {
                    //要想等于0；和要变大，left向右移
                    left++;
                }
                else if (nums[i] + nums[left] + nums[right] > 0) {
                    right--;
                }
                else {
                    //找到符合的，收集结果
                    res.push_back(vector<int>{nums[i], nums[left], nums[right]});
                    //对b,c去重，这步不能放在收集结果之前
                    while (left < right && nums[left] == nums[left + 1]) left++;
                    while (left<right && nums[right] == nums[right - 1]) right--;
                    //找到符合的，左右指针同时向中间移
                    left++;
                    right--;
                }
            }
        }
        return res;
    }
};

注意：是判断nums[i]==num[i+1]还是nums[i]==nums[i-1]呢，要知道题目要求的是不能有重复的三元组，但三元组中的数是可以重复的，举例子就是不能有[[-3,1,2],[-3,1,2,]]但可以是[[-1,-1,2],[-1,0,1]],既然要判断nums[i[==nums[i-1]首先得保证i-1>=0

left,right指针移动，是while(left<=right)还是while(left<right).如果left和right相等，那么他们指向数组中的同一个数，那就不是三个数的和了，所以是while(left<right)

a去重，b,c也要去重，但这个去重一定要放在收获结果之和，至少收获到了结果，再进行去重，例如0，0，0，0，0，0这种，如果把b,c的去重放在收获结果之前，那么一个结果都没有了

这个可以先判断下，刚开始没写也通过了

// 排序之后如果第一个元素已经大于零，那么不可能凑成三元组
            if (nums[i] > 0) {
                break;
            }

18.四数之和

题目：力扣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循坏外再套一层for循环，同样靠left,right向中间移动寻找合适的数

注意：三数相加那道题是a+b+c=0,那么如果第一个数大于0，就不存在符合的三元组，但这道题是a+b+c+d=target而不是为0，这就不能用 if(nums[k]>target)判断，因为这些数可能有正有负，加上一个正数和变大，但加一个负数和就变小了，而应该是 if (nums[k] > target && nums[k] >= 0)

#include<vector>
#include<algorithm>
using namespace std;

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> res;
        //排序
        sort(nums.begin(), nums.end());
        for (int k = 0; k < nums.size(); k++) {
            if (nums[k] > target && nums[k] >= 0) {
                break; // 这里使用break，统一通过最后的return返回
            }
            // 对nums[k]去重
            if (k > 0 && nums[k] == nums[k - 1]) {
                continue;
            }
            for (int i = k + 1; i < nums.size(); i++) {
                // nums[k]+nums[i]看作一个整体
                if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {
                    break;
                }
                // 对nums[i]去重
                if (i > k + 1 && nums[i] == nums[i - 1]) {
                    continue;
                }
                int left = i + 1;
                int right = nums.size() - 1;
                while (right > left) {
                    // nums[k] + nums[i] + nums[left] + nums[right] > target 会溢出
                    if ((long)nums[k] + nums[i] + nums[left] + nums[right] > target) {
                        right--;
                        // nums[k] + nums[i] + nums[left] + nums[right] < target 会溢出
                    }
                    else if ((long)nums[k] + nums[i] + nums[left] + nums[right] < target) {
                        left++;
                    }
                    else {
                        res.push_back(vector<int>{nums[k], nums[i], nums[left], nums[right]});
                        while (left < right && nums[left] == nums[left + 1]) left++;
                        while (left < right && nums[right] == nums[right - 1]) right--;
                        //找到符合的，左右指针同时向中间移
                        left++;
                        right--;
                    }
                }

            }
        }
        return res;
    }
};

幺幺绛

关注

19
点赞
踩
26

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫