训练营Day06 |454. 四数相加 II| 383. 赎金信| 15. 三数之和

最新推荐文章于 2024-10-09 20:50:45 发布

Gentea

最新推荐文章于 2024-10-09 20:50:45 发布

阅读量1.7k

点赞数

分类专栏： Leetcode 文章标签： leetcode 算法哈希算法

本文链接：https://blog.csdn.net/Gentea/article/details/131262759

版权

Leetcode 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

454. 四数相加 II

本题解题步骤：

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

/*
 * @lc app=leetcode.cn id=454 lang=cpp
 *
 * [454] 四数相加 II
 */

// @lc code=start
class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int, int> umap;
        for(int a : A){
            for(int b : B){
                //统计的是a+b的和，和它出现的次数
                umap[a + b]++;
            }
        }
        int count = 0;
        //找0-（c+d）
        for(int c : C){
            for(int d: D){
                if(umap.find(0- (c + d)) != umap.end()){
                    count += umap[0 - (c + d)];
                } 
            }
        }
        return count;
    }
};
// @lc code=end

383. 赎金信

1.暴力

2.哈希找东西有没有问题，空间换时间

3.题目中要找的只有小写字母，所以可以考虑用数组来存放值，索引就是按ASCII码排序，利用（array[i] - ’a‘）的操作

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int record[26] = {0};

        if(magazine.size() < ransomNote.size()){
            return false;
        }

        for(int i = 0; i < magazine.length(); i++){
            //record中记录magazine中字符出现次数
            record[magazine[i] - 'a']++;
        }

        for(int j = 0; j < ransomNote.length(); j++){
            record[ransomNote[j] - 'a']--;
            //如果出现了val<0的情况，说明ransomNote中出现的字符maagzine中没有
            if(record[ransomNote[j] - 'a'] < 0){
                return false;
            }
        }
        return true;
    }
};

15. 三数之和！！

哈希法！超出时间限制

两层for循环就可以确定 a 和b 的数值了，可以使用哈希法来确定 0-(a+b) 是否在数组里出现过，其实这个思路是正确的，但是我们有一个非常棘手的问题，就是题目中说的不可以包含重复的三元组。

去重的过程不好处理，有很多小细节，如果在面试中很难想到位。

/*
 * @lc app=leetcode.cn id=15 lang=cpp
 *
 * [15] 三数之和
 */

// @lc code=start
class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        //哈希法
        //初始化
        vector<vector<int>> result;

        //按顺序遍历，有利于去重
        sort(nums.begin(), nums.end());
        //进入数组遍历
        for(int i = 0; i < nums.size(); i++){
            
            //利用排序，如果首个元素>0,则不会满足条件
            if(nums[i] > 0){
                break;
            }
            //去重
            //如果不限制i>0,在i=0的时候会和i=-1比较
            if(i > 0 && nums[i] == nums[i - 1]){
                continue;
            }
            //按序遍历，去重第一个元素

            //建立一个set，因为set本身就可以去重
            //存放每次遍历到的b 通过在新的遍历中寻找之前的值c判断能否符合条件
            unordered_set<int> set;

            for(int j = i + 1; j < nums.size(); j++){
                //对j去重
                //j>i+2 也就意味着已经遍历了i+1,i+2,对其进行一次去重操作
                if(j > i + 2 && nums[j] == nums[j - 2]
                && nums[j] == nums[j - 1]){
                    continue;
                }

                int c = 0 - (nums[j] + nums[i]);

                //!= 说明有c满足条件,c其实是历史的值，i和j是正在遍历的值
                if(set.find(c) != set.end()){
                    result.push_back({nums[i], nums[j], c});
                    //对c的值进行去重，防止重复
                    set.erase(c);
                }else{
                    //如果没找到就将j的值存入set
                    set.insert(nums[j]);
                }
            }
        }
        return result;




    }
};
// @lc code=end

双指针法

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
       

        //双指针法
        vector<vector<int>> result;

        sort(nums.begin(), nums.end());

        for(int i = 0; i < nums.size(); i++){
            
            if(nums[i] > 0){
                return result;
            }

            // 错误去重a方法，将会漏掉-1,-1,2 这种情况
            /*
            if (nums[i] == nums[i + 1]) {
                continue;
            }
            */
            // 正确去重a方法
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }

            int left = i + 1;
            int right = nums.size() - 1;
            //不考虑重复情况 无=
            while(right > left){
                //前后去重的区别

                // 去重复逻辑如果放在这里，0，0，0 的情况，
                //可能直接导致 right<=left 了，从而漏掉了 0,0,0 这种三元组
                /*
                while (right > left && nums[right] == nums[right - 1]) right--;
                while (right > left && nums[left] == nums[left + 1]) left++;
                */

               if(nums[i] + nums[left] + nums[right] > 0){
                right--;
               }else if(nums[i] + nums[left] + nums[right] < 0)
               {
                left++;
               }else{
                result.push_back(vector<int>{nums[i], nums[left], nums[right]});

                //加入后去重,对b和c去重
                while(right > left && nums[right] == nums[right - 1]) right--;
                while(right > left && nums[left] == nums[left + 1]) left++;

                //找到答案，收缩指针
                right--;
                left++;
               }
            }

        }
        return result;
    }
};

去重逻辑的思考

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;
}

1
2
3

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

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

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

那么应该这么写：

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

1
2
3

这么写就是当前使用 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 {
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

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

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

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

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

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