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

合集 - 代码训练营(13)

1.代码随想录算法训练营第一天| 704. 二分查找、27. 移除元素2024-06-252.代码随想录算法训练营第二天| 977. 有序数组的平方、209. 长度最小的子数组、59. 螺旋矩阵 II2024-06-263.代码随想录算法训练营第四天| 203. 移除链表元素、707.设计链表、206.反转链表2024-06-264.代码随想录算法训练营第五天| 24. 两两交换链表中的节点、19.删除链表的倒数第N个节点、面试题 02.07. 链表相交(同160题)、142.环形链表Ⅱ2024-06-265.代码随想录算法训练营第六天| 242. 有效的字母异位词、349.两个数组的交集、202.快乐数、1.两数之和2024-06-26

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

7.代码随想录算法训练营第八天|344.反转字符串、541.反转字符串Ⅱ、54.替换数字(卡码网是真滴不好用)2024-07-048.代码随想录算法训练营第九天|151.反转字符串中的单词、55.右旋字符串、28.找出字符串中第一个匹配项的下标、459.重复的子字符串2024-07-049.代码随想录算法训练营第十一天|232.用栈实现队列、225.用队列实现栈、20.有效的括号、1047.删除字符串中的所有相邻重复项2024-07-0410.代码随想录算法训练营第十二天|150.逆波兰表达式求值、239.滑动窗口最大值、347.前k个高频元素2024-07-0411.代码随想录算法训练营第十三天|今天量大管饱144、145、94、102、107、199、637、429、515、116、117、104、1112024-07-0512.代码随想录算法训练营第十四天| 226.翻转二叉树 、101. 对称二叉树、104.二叉树的最大深度 （优先掌握递归）、111.二叉树的最小深度2024-07-0513.代码随想录算法训练营第十五天|110.平衡二叉树、257.二叉树的所有路径、404.左叶子之和、222.完全二叉树的节点个数2024-07-05

收起

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;
    }
};

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