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

CAriaTLOVER

已于 2023-09-13 11:14:34 修改

阅读量45

点赞数

文章标签：算法

于 2023-09-12 22:27:30 首次发布

本文链接：https://blog.csdn.net/m0_63521007/article/details/132823301

版权

454. 四数相加Ⅱ

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

视频讲解：学透哈希表，map使用有技巧！LeetCode：454.四数相加II_哔哩哔哩_bilibili

文章讲解：代码随想录

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int, int> map;
        int count = 0;
        for(int i=0; i<nums1.size(); i++){
            for(int j=0; j<nums2.size(); j++){
                map[nums1[i]+nums2[j]]++;
            }
        }
        for(int k=0; k<nums3.size(); k++){
            for(int l=0; l<nums4.size(); l++){
                int target = 0-(nums3[k]+nums4[l]);
                if(map.find(target)!=map.end()){
                    count += map[target];
                }
            }
        }
        return count;
    }
};

时间复杂度: O(n^2)
空间复杂度: O(n^2)，最坏情况下A和B的值各不相同，相加产生的数字个数为 n^2

383. 赎金信

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

无视频讲解，与 242.有效的字母异位词是一个思路

文章讲解：代码随想录

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        unordered_map<int, int> map;
        for(int i=0; i<magazine.size(); i++){
            map[magazine[i]]++;
        }
        for(int i=0; i<ransomNote.size(); i++){
            if(map.find(ransomNote[i])!=map.end()){
                if(map[ransomNote[i]]==0) return false;
                map[ransomNote[i]]--;
            }
            else return false;
        }
        return true;
    }
};

时间复杂度: O(n)
空间复杂度: O(1)

在本题的情况下，使用map的空间消耗要比数组大一些的，而且还要做哈希函数，是费时的！数据量大的话就能体现出来差别了。所以数组更加简单直接有效！

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        // 由于字符只有26个，用数组来解
        int array[26] = {0};
        for(int i=0; i<magazine.size(); i++){
            array[magazine[i]-'a']++;
        }
        for(int i=0; i<ransomNote.size(); i++){
            if(array[ransomNote[i]-'a']==0) return false;
            else array[ransomNote[i]-'a']--;
        }
        return true;
    }
};

15. 三数之和

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

视频讲解：梦破碎的地方！| LeetCode：15.三数之和_哔哩哔哩_bilibili

文章讲解：代码随想录

【双指针法：由于不需要返回下标，可以先对数组进行排序】

【题目要求去重，求解时一定注意去重】

【三元组里的元素是可以重复的】

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()-2; i++){
            if(nums[i]>0) return result;
            // 对a进行去重
            if(i>0 && nums[i]==nums[i-1]) continue;
            int left = i+1;
            int right = nums.size()-1;
            while(left<right){  // 注意这里的边界判断，left!=right
                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]});
                    left++;
                    right--;
                    while(left<right && nums[left]==nums[left-1]) left++;
                    while(left<right && nums[right]==nums[right+1]) right--;                    
                }                 
            }
        }
        return result;
    }
};

18. 四数之和

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

视频链接：难在去重和剪枝！| LeetCode：18. 四数之和_哔哩哔哩_bilibili

文章链接：代码随想录

【延续了三数之和的思路】

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        sort(nums.begin(),nums.end());
        if(nums.size()<4) return {};
        for(int k=0; k<nums.size()-1; k++){
            // 剪枝
            if(nums[k]>target/4) return result;
            if(k>0 && nums[k]==nums[k-1]) continue;
            for(int i=k+1; i<nums.size(); i++){
                if(nums[i]+nums[k]>target/2) break;  // 注意这里是break
                // 注意这里剪枝
                if(nums[i]==nums[i-1] && i>k+1) continue;
                int left = i+1;
                int right = nums.size()-1;
                while(left<right){
                    if((long)nums[k]+nums[i]+nums[left]+nums[right]<target) left++;  // 注意这里用long
                    else if((long)nums[k]+nums[i]+nums[left]+nums[right]>target) right--;
                    else{
                        result.push_back(vector<int> {nums[k], nums[i], nums[left], nums[right]});
                        left++;
                        right--;
                        while(left<right && nums[left]==nums[left-1]) left++;
                        while(left<right && nums[right]==nums[right+1]) right--;                       
                    }
                }
            }
        }
        return result;
    }
};