代码随想录算法训练营第7天|LeetCode454.四数相加||、LeetCode383.赎金信、LeetCode15.三数之和、LeetCode18.四数之和

代码随想录算法训练营第7天|LeetCode454.四数相加||、LeetCode383.赎金信、LeetCode15.三数之和、LeetCode18.四数之和

1、LeetCode454.四数相加||

是哈希表中经典的题。

题目：454. 四数相加 II - 力扣（LeetCode）
文章：代码随想录 (programmercarl.com)
视频：学透哈希表，map使用有技巧！LeetCode：454.四数相加II_哔哩哔哩_bilibili

第一想法

只能想到暴力相加…四个for循环，和为0则count++。

解题思路

思路：
四个数组A, B, C, D，遍历A和B中的数组求和放到哈希表中，当遍历C和D的求和时，去找哈希表中符合条件的AB之和。

遍历AB时间复杂度n² ，遍历CD时间复杂度n² ，因此总的时间复杂度n² 。

哈希表结构选择：

• int之和很大，因此不考虑用数组；
• 不仅要统计是否出现过，还要统计出现过的次数；如果set的话只有一个set存key；
• 因此选择map存key，value。

count：当CD找到目标数后，count＋value值而不是+1。

代码

掌握一下for循环新写法！！！

    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int,int> m;
        int count = 0;
        //原来for循环还可以这样写！！
        for(int i:nums1){
            for(int j:nums2){
                int sum = i+j;
                if(m.find(sum) != m.end())
                    m[sum]++;
                else
                    m.insert({sum, 1});
            }
        }

        for(int i:nums3){
            for(int j:nums4){
                int target = 0-(i+j);
                if(m.find(target) != m.end()){
                    count += m[target];
                }
            }
        }
        return count;

    }

总结： 和“有效的字母异位词”很像，都是两个循环，一个存，一个查。

2、LeetCode383.赎金信

和“242.有效的字母异位词”是一个思路，算是拓展题。

题目：383. 赎金信 - 力扣（LeetCode）
文章：代码随想录 (programmercarl.com)

第一想法

先遍历magazine，记录每个字母出现次数；再遍历ransomNote，查找。

我的思路对了！！代码写得也很快直接过了！！！

代码

犯错：获取string的长度的时候写成了.length，实际上应该写.length()。是函数而不是属性。

    bool canConstruct(string ransomNote, string magazine) {
        int arr[26]={0};
        for(int i=0; i < magazine.length() ;i++){
            arr[magazine[i] - 'a'] ++;
        }
        for(int i=0;i <ransomNote.length() ;i++){
            if(arr[ransomNote[i] - 'a'] == 0)
                return false;
            else
                arr[ransomNote[i] - 'a'] --;
        }
        return true;

    }

3、LeetCode15.三数之和

和四数之和（4个数组）不同的是，这里只有1个数组，并且元素需要去重。

题目：15. 三数之和 - 力扣（LeetCode）(https://leetcode.cn/problems/ransom-note/description/)
文章：代码随想录 (programmercarl.com)
视频：梦破碎的地方！| LeetCode：15.三数之和_哔哩哔哩_bilibili

第一想法

先两个for，把和存进哈希表；再用一个for去找target。

没有考虑到去重，
输入： nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。

解题思路

使用哈希法去重会很复杂。

双指针法： 先对数组进行排序，固定i，left从左开始，right从右开始，若三数之和>0，则right–；若<0，则left++。

注意：

• i，left，right都要进行去重。
• nums[i]>0，可以直接return
• i去重——和前一个比较
  

代码

犯错：

• 二维vector定义写成来vector<int , vector<int> > ans，实际上应该写成vector<vector<int>> result！！！

    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int> > ans;
        //先排序！！别忘了
        sort(nums.begin(), nums.end());
        for(int i=0; i<nums.size() ;i++){
            if(nums[i] > 0)
                return ans;
            // i去重   //注意这里为什么是i-1
            if(i > 0 && nums[i] == nums[i-1]){ 
                continue;
            }
            int left = i+1;
            int right = nums.size()-1;
            while(right > left){
                if(nums[i] + nums[left] + nums[right] > 0)
                    right--;
                else if(nums[i] + nums[left] + nums[right] < 0)
                    left++;
                else{
                    //插入新元组
                    ans.push_back(vector<int>{nums[i], nums[left], nums[right]});
                    //left，right去重
                    while(right > left && nums[left] == nums[left+1])   left++;
                    while(right > left && nums[right] == nums[right-1])   right--;

                    //同时往中间缩
                    left++;
                    right--;
                }
            }
            
        }
        return ans;
    }

4、LeetCode18.四数之和

延续15.三数之和的思路，在三数之和的基础上多加一个for。
和454.四数之和||（4个数组）的区别：。

题目：18. 四数之和 - 力扣（LeetCode）(https://leetcode.cn/problems/ransom-note/description/)
文章：代码随想录 (programmercarl.com)
视频：难在去重和剪枝！| LeetCode：18. 四数之和_哔哩哔哩_bilibili

解题思路

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

细节：剪枝+去重

剪枝：当第一个数>target，直接return了，是不行的，因为如果target是负数，而数组中也有负数，那么仍存在答案。

代码

这个代码没时间自己动手敲，等二刷的时候来。

    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        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++) {
                // 2级剪枝处理
                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 {
                        result.push_back(vector<int>{nums[k], nums[i], nums[left], nums[right]});
                        // 对nums[left]和nums[right]去重
                        while (right > left && nums[right] == nums[right - 1]) right--;
                        while (right > left && nums[left] == nums[left + 1]) left++;

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

            }
        }
        return result;
    }

总结

• why哈希法
• why这个数据结构
• map的key，value分别存的是什么
• 思路一个for循环存，另一个for循环查是否存在
• for循环新写法for(int i : nums)
• string的长度=string.length()