代码随想录D7

最新推荐文章于 2024-09-14 22:25:23 发布

qq_21609915

最新推荐文章于 2024-09-14 22:25:23 发布

阅读量438

点赞数 4

文章标签：算法 leetcode 职场和发展

本文链接：https://blog.csdn.net/qq_21609915/article/details/137522368

版权

54.四数相加II

学习资料

题目链接/文章讲解/视频讲解：代码随想录

代码

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4){
        unordered_map<int,int> ijSum;

        for(int i : nums1){
            for(int j : nums2){
                ijSum[i + j]++;
            }
        }
        
        int count = 0;
        

        for(int k : nums3){
            for(int l : nums4){
                auto it = ijSum.find(-k - l);
                if(it != ijSum.end()){
                    count += it->second;
                }
            }
        }

        return count;
    }
};

383. 赎金信

学习资料

题目链接/文章讲解：代码随想录

代码

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        unordered_map<char,int> dictionary;

        for(char c : ransomNote){
            dictionary[c]++;
        }

        for(char c : magazine){
            if(dictionary.count(c)){
                dictionary[c]--;
            }
        }

        for(auto it : dictionary){
            if(it.second > 0){
                return false;
            }
        }

        return true;
    }
};

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int dictionary[26];

        for(char c : magazine){
            dictionary[c- 'a']++;
        }

        for(char c : ransomNote){
            dictionary[c - 'a']--;
        }

        for(int i : dictionary){
            if(i < 0){
                return false;
            }
        }
        return true;
    }
};

15. 三数之和

学习资料

题目链接/文章讲解/视频讲解：代码随想录

代码

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        vector<vector<int>> ans;

        int left;
        int right;
        int target;

        for(int i = 0; i < nums.size() - 1;){
            left = i + 1;
            right = nums.size() - 1;
            target = 0 - nums[i];

            if (nums[i] > 0) {
                return ans;
            }

            while(left < right){
                if(nums[left] + nums[right] == target){
                    ans.push_back({nums[i],nums[left],nums[right]});

                    while(nums[left] == nums[left + 1] && left + 1 < right){
                        left++;
                    }
                    left++;

                    while(nums[right - 1] == nums[right] && right - 1 > left){
                        right--;
                    }
                    right--;  
                }
                else if(nums[left] + nums[right] < target){
                    while(nums[left] == nums[left + 1] && left + 1 < right){
                        left++;
                    }
                    left++;
                }
                else{
                    while(nums[right - 1] == nums[right] && right - 1 > left){
                        right--;
                    }
                    right--; 
                }
            }
            while(nums[i] == nums[i + 1] && i + 1 < nums.size() - 1){
                i++;
            }
            i++;
        }
        return ans;
    }
};

18. 四数之和

学习资料

题目链接/文章讲解/视频讲解：代码随想录

代码

和三数之和一样的方法，有一些int越界问题用了粗暴地改变量类型解决

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        sort(nums.begin(),nums.end());
        vector<vector<int>> ans;

        int left;
        int right;
        long last_two_sum;

        for(int i = 0; i < nums.size() - 1;){
            for(int j = i + 1; j < nums.size() - 1;){
                left = j + 1;
                right = nums.size() - 1;
                last_two_sum = (long)target - (long)nums[i] - (long)nums[j];

                

                while(left < right){
                    if((long)(nums[left] + nums[right]) == last_two_sum){
                        ans.push_back({nums[i],nums[j],nums[left],nums[right]});

                        while(nums[left] == nums[left + 1] && left + 1 < right){
                            left++;
                        }
                        left++;

                        while(nums[right - 1] == nums[right] && right - 1 > left){
                            right--;
                        }
                        right--;  
                    }
                    else if((long)(nums[left] + nums[right]) < last_two_sum){
                        while(nums[left] == nums[left + 1] && left + 1 < right){
                            left++;
                        }
                        left++;
                    }
                    else{
                        while(nums[right - 1] == nums[right] && right - 1 > left){
                            right--;
                        }
                        right--; 
                    }
                }
                while(nums[j] == nums[j + 1] && j + 1 < nums.size() - 1){
                    j++;
                }
                j++;
            }
            while(nums[i] == nums[i + 1] && i + 1 < nums.size() - 1){
                i++;
            }
            i++;
        }
        return ans;
    }
};

增加一些剪枝优化

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        sort(nums.begin(),nums.end());
        vector<vector<int>> ans;

        int left;
        int right;
        long last_two_sum;

        for(int i = 0; i < nums.size() - 1;){
            if (nums[i] > target && nums[i] >= 0) {
            	break;
            }

            for(int j = i + 1; j < nums.size() - 1;){
                if (nums[i] + nums[j] > target && nums[i] + nums[j] >= 0) {
                    break;
                }

                left = j + 1;
                right = nums.size() - 1;
                last_two_sum = (long)target - (long)nums[i] - (long)nums[j];

                while(left < right){
                    if((long)(nums[left] + nums[right]) == last_two_sum){
                        ans.push_back({nums[i],nums[j],nums[left],nums[right]});

                        while(nums[left] == nums[left + 1] && left + 1 < right){
                            left++;
                        }
                        left++;

                        while(nums[right - 1] == nums[right] && right - 1 > left){
                            right--;
                        }
                        right--;  
                    }
                    else if((long)(nums[left] + nums[right]) < last_two_sum){
                        while(nums[left] == nums[left + 1] && left + 1 < right){
                            left++;
                        }
                        left++;
                    }
                    else{
                        while(nums[right - 1] == nums[right] && right - 1 > left){
                            right--;
                        }
                        right--; 
                    }
                }
                while(nums[j] == nums[j + 1] && j + 1 < nums.size() - 1){
                    j++;
                }
                j++;
            }
            while(nums[i] == nums[i + 1] && i + 1 < nums.size() - 1){
                i++;
            }
            i++;
        }
        return ans;
    }
};