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

454题拆成两块 各自匹配 化成两个O(n^2)运算

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        //四个数组拆分成两块 两块 
        unordered_map<int,int> sum;
        int ans = 0;
        for (int n1:nums1) {
            for (int n2:nums2) {
                sum[n1+n2]++;
            }
        }
        for (int n3:nums3) {
            for (int n4:nums4) {
                if (sum.find(0-n3-n4) != sum.end()) {
                    ans += sum[0-n3-n4];//加上这个要求的次数 
                }
            }
        }
        return ans;
    }
};

383题笨方法 统计 计数

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        unordered_map<char, int> charCount;
        for (char t:ransomNote) {
            charCount[t]--;
        }
        for (char s:magazine) {
            charCount[s]++;
        }
        for (char ch = 'a'; ch <= 'z'; ++ch) {
            if (charCount[ch] < 0) {
                return false;
            }
        }
        return true;
    }
};

15题琢磨了很久 哈希表法太容易超时了 还得是双指针法啊

//上来就三重循环 有点难绷得住
//那不能三重循环 直接空间换时间？
//第一遍 遍历 我按下标存放
class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> ans;
        unordered_map<int, vector<pair<int, int>>> myMap;

        // 构建哈希表，存储所有满足条件的 (i, j) 组合
        for (int i = 0; i < nums.size(); ++i) {
            for (int j = i + 1; j < nums.size(); ++j) {
                int sum = nums[i] + nums[j];
                myMap[sum].push_back({i, j});
            }
        }

        // 查找满足条件的三元组 (i, j, k)
        for (int k = 0; k < nums.size(); ++k) {
            int target = 0 - nums[k];

            if (myMap.find(target) != myMap.end()) {
                for (auto& pair : myMap[target]) {
                    int i = pair.first;
                    int j = pair.second;
                    if (k != i && k != j) {
                        vector<int> triplet = {nums[i], nums[j], nums[k]};
                        sort(triplet.begin(), triplet.end());
                        ans.push_back(triplet);
                    }
                }
            }
        }

        // 使用 set 去重
        set<vector<int>> unique_ans(ans.begin(), ans.end());
        ans.assign(unique_ans.begin(), unique_ans.end());

        return ans;
    }
};
//辛辛苦苦写的哈希算法 直接超时 好好好好 换到双指针法

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> ans;
        sort(nums.begin(), nums.end());
        int n = nums.size();
        for (int i = 0; i < n - 2; ++i) {
            if (i > 0 && nums[i] == nums[i - 1]) continue; // 跳过重复的元素

            int left = i + 1;
            int right = n - 1;
            while (left < right) {
                int sum = nums[i] + nums[left] + nums[right];
                if (sum == 0) {
                    ans.push_back({nums[i], nums[left], nums[right]});
                    while (left < right && nums[left] == nums[left + 1]) left++; // 跳过重复的元素
                    while (left < right && nums[right] == nums[right - 1]) right--; // 跳过重复的元素
                    left++;
                    right--;
                } else if (sum < 0) {
                    left++;
                } else {
                    right--;
                }
            }
        }
 
    // sort(ans.begin(), ans.end());
    // ans.erase(unique(ans.begin(), ans.end()), ans.end());
    //这个去重操作要好好学学  不用学了 多余的 
    return ans;
    }
};

18题就是15题套皮 多加一层循环

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        //可不可以在三数之和基础上加一层循环
        vector<vector<int>> ans;
        sort(nums.begin(), nums.end());
        int n = nums.size();
        
        for (int i = 0; i < n - 3; ++i) {
            if (i > 0 && nums[i] == nums[i - 1]) continue; // 跳过重复的元素
            
            for (int j = i + 1; j < n - 2; ++j) {
                if (j > i + 1 && nums[j] == nums[j - 1]) continue; // 跳过重复的元素
                
                int left = j + 1;
                int right = n - 1;
                
                while (left < right) {
                    long long sum = static_cast<long long>(nums[i]) + nums[j] + nums[left] + nums[right];
                    if (sum == target) {
                        ans.push_back({nums[i], nums[j], nums[left], nums[right]});
                        while (left < right && nums[left] == nums[left + 1]) left++; // 跳过重复的元素
                        while (left < right && nums[right] == nums[right - 1]) right--; // 跳过重复的元素
                        left++;
                        right--;
                    } else if (sum < target) {
                        left++;
                    } else {
                        right--;
                    }
                }
            }
        }
        
        return ans;
    }
};

许久没跟着刷题了，不说了 开工！