哈希表&双指针

最新推荐文章于 2024-10-16 10:13:45 发布

Hanknet

最新推荐文章于 2024-10-16 10:13:45 发布

阅读量52

点赞数

分类专栏： leetCode 文章标签： leetcode 算法数据结构 c++ Powered by 金山文档

本文链接：https://blog.csdn.net/Hanknet/article/details/129140934

版权

leetCode 专栏收录该内容

50 篇文章 0 订阅

订阅专栏

文章介绍了使用排序和双指针方法解决寻找数组中和为目标值的三数组合和四数组合的问题，以及利用哈希表高效处理赎金信和四数相加II的场景。涉及时间复杂度和空间复杂度分析。

摘要由CSDN通过智能技术生成

15. 三数之和

方法：排序+双指针

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>>res;
        int i, l, r, n=nums.size();
        sort(nums.begin(), nums.end());
        if(nums[0] > 0 || nums[n-1] < 0 || n < 3) return res;
        if(nums[0] == 0 && nums[n-1] == 0) return {{0, 0, 0}};

        for(i = 0; i < n-2; ++i) {
            if(i && nums[i] == nums[i-1]) continue;
            if(nums[i] > 0) break;
            l = i+1;
            r = n-1;
            while(l < r) {
                int target = nums[i]+nums[l]+nums[r];
                if(target > 0) --r;
                else if(target < 0) ++l;
                else {
                    res.push_back({nums[i], nums[l], nums[r]});
                    ++l;
                    --r;
                    while(l < r && nums[l] == nums[l-1]) ++l;
                    while(l < r && nums[r] == nums[r+1]) --r;
                }
            } 
        }
        return res;
    }
};

$时间复杂度O( $\text{[math]}$ )，空间复杂度O(1)

18. 四数之和

方法：双指针+排序

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>>ret;
        int i, j, l, k;
        int n = nums.size();
        if(n < 4) {
            return ret;
        }

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

        long long sum4 = (long long)nums[0] + nums[1] + nums[2] + nums[3];
        long long max3 = (long long)nums[n-1] + nums[n-2] + nums[n-3];
        long long sum3 = 0;
        long long max2 = (long long)nums[n-1] + nums[n-2];

        for(i = 0; i < n - 3; ++i) {
            if(sum4 > target) {
                break;
            }
            if(i+4 < n) {
                sum4 = sum4 - nums[i] + nums[i+4];
            }
            if(i > 0 && nums[i] == nums[i-1]) {
                continue;
            }

            if(max3 + nums[i] < target) {
                continue;
            }

            sum3 = (long long)nums[i] + nums[i+1] + nums[i+2] + nums[i+3];

            for(j = i + 1; j < n - 2; ++j) {
                if(sum3 > target) {
                    break;
                }
                if(j+3 < n) {
                    sum3 = sum3;
                }
                if(j > i + 1 && nums[j] == nums[j-1]) {
                    continue;
                }
                long long val = (long long)target - nums[i] - nums[j];
                if(max2 < val) {
                    continue;
                }
                int l = j + 1;
                int k = n - 1;
                while(l < k) {
                    long long sum = nums[l] + nums[k];
                    if(sum > val) {
                        --k;
                    }else if(sum < val) {
                        ++l;
                    }else {
                        ret.push_back({nums[i], nums[j], nums[l], nums[k]});
                        --k;
                        ++l;
                        while(l < k && nums[k] == nums[k+1]) --k;
                        while(l < k && nums[l] == nums[l-1]) ++l;
                    }
                }
            }
        }
        ret.shrink_to_fit();
        return ret;  
    }
};

$时间复杂度O( $\text{[math]}$ )，空间复杂度O(1)

383. 赎金信

方法:哈希表

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int a[100010] = {0};
        if(ransomNote.size() > magazine.size()) return false;
        for(int u : magazine) ++a[u];
        for(int u : ransomNote) {
            --a[u];
            if(a[u] < 0) return false;
        }
        return true;
    }
};

$时间复杂度O(n)，空间复杂度O(26)

454. 四数相加 II

方法：哈希表

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int, int>cnt;
        for(int a : nums1) {
            for(int b : nums2) {
                ++cnt[a+b];
            }
        }
        int res = 0;
        for(int c : nums3) {
            for(int d : nums4) {
                if(cnt.find(-c-d) != cnt.end()) res += cnt[-c-d];
            }
        }
        return res;
    }
};

$时间复杂度O( $\text{[math]}$ )，空间复杂度O(n)