代码随想录DAY7

📚 [LeetCode 454. 四数相加]

💡 解题思路
1. 问题抽象
提供四个数组和一个target值，要求找出有多少个四元数组（从各数组取一个数）满足四数相加等于target。（不同于四数之和，本题不用去重）

2. 核心代码（C++）

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

⚠️ 思维困境
看完视频自己写一遍挺快的
易错：声明map要说明key和value两个数据类型
知识点：“for (num : nums)” 写法叫做 范围-based for 循环（range-based for），语法如下：

for (auto 变量 : 容器) { ... }

🔍 复杂度分析
时间：O(N^2) 
空间：O(N^2) 

📚 [ LeetCode 15.三数之和]

💡 解题思路
1. 问题抽象
对于给定数组，取三个数使 a+b+c = target，a, b, c 内部三个数字可以相等，但三元数组之间不能相同。最后以二维数组的形式返回 result. 双指针思想比较好，如果使用哈希法则与四数相加类似，但由于要去重会增加工作量。

2. 核心代码（C++）

    vector<vector<int>> threeSum(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        vector<vector<int>> result;
        for (int i = 0; i < nums.size(); i++) {
            if (i > 0 && nums[i] == nums[i - 1])
                continue;
            int left = i + 1;
            int right = nums.size() - 1;
            while (left < right) {
                if (nums[i] + nums[left] + nums[right] > 0) {
                    right--;
                } else if (nums[i] + nums[left] + nums[right] < 0) {
                    left++;
                } else if (nums[i] + nums[left] + nums[right] == 0) {
                    result.push_back({nums[i], nums[left], nums[right]});
                    while (left < right && nums[right] == nums[right - 1])
                        right--;
                    right--;
                    while (left < right && nums[left] == nums[left + 1])
                        left++;
                }
            }
        }
        return result;
    }

⚠️ 思维困境
有点绷不住，debug了半天发现最前面忘记sort了。其实我的代码其实最前面应该像卡哥说的加一句 if (nums[i] >= target) return result（哦原来这叫剪枝）。
本题的思路蛮巧妙的。理解上有三个核心点：
1. 双指针：将数字从小到大排列之后，i 从头开始遍历，这是第一重循环。right 从 nums.size() 开始遍历，一旦和大于 target 则 -- ；left 从 i+1 开始遍历，一旦和小于 target 则 ++；循环条件是 left < right . 为什么此方法能确保涵盖所有情况呢？最重要的是，sort 之后就能保证不论是哪个指针只要单方向往前走就能确保递增/递减。全过程可以这么理解：i 和 right 确定的区间内，让 left 从前往后遍历。

2. i 的去重：特别有趣地，判断条件 nums[ i ] == nums[ i+1 ] 与 nums[ i ] == nums[ i-1 ] 效果完全不同。前者会让三元数组内第一个数和第二个数不相同；后者才是让三元数组之间不相同的第一步操作，对 i 去重。

3. left 和 right 的去重：此处不同于第2点，判断条件是 nums[ left ] == nums[ left+1 ] 与 nums[ right ] == nums[ right -1 ]，即，将当前数字与即将遍历的（可能重复的）数字比较，而不是与上一个遍历过的比较（第2点的情况）。这个时候会不会出现“排除三元数组内相同的情况，而非真正去重”呢？不会，因为此时的结果仅依赖于 left 和 right 两个指针缩小“区间”了。设想现在指针分布情况如下:（尖括号内分别是 i, left, right 指向的数字）

target = 6
<1> 1 <2> 2 3 <3>

此时指针已经满足target了，当 nums[ left ] == nums[ left +1 ]不可能出现 nums[ left ] 和 nums[ left+1 ]同时在 result 的一个三元数组内的情况，因为若 target == 5，right 一定已经逼近到如上第二个 2 的位置了。

这里需要留意的点是，该去重操作时仅在“三数相加等于target”的 if 内进行，且必须要把当前数字存入result后进行（否则对于数列中间存在重复数字的情况，如222333，会直接没有保存当前result直接退出大循环）。

易错点：对于 left 和 right 的去重也要加上 left < right 的判断，不然会越界。
知识点：std::sort函数位于<algorithm>头文件中，用法如下：

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

🔍 复杂度分析
时间：O(N^2) 
空间：O(1) sort 是原地排序算法，它不会额外占用与输入数组大小成比例的空间。因此，排序操作的空间复杂度为 O(1)。在空间复杂度分析中，通常不计算输出结果所占用的空间。因此，result 的空间占用不计入算法的空间复杂度。

📚 [LeetCode 18. 四数之和]

💡 解题思路
1. 问题抽象
思路与三数之和比较一致，就是要在最外面再套一层for循环。

2. 核心代码（C++）

    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        sort(nums.begin(), nums.end());
        vector<vector<int>> result;

        for (int k = 0; k < nums.size(); k++) {
            if (target >= 0 && nums[k] != 0 && nums[k] >= target)
                break;
            if (k > 0 && nums[k] == nums[k - 1])
                continue;
            for (int i = k + 1; i < nums.size(); i++) {
                if (target >= 0 && nums[k] + nums[i] != 0 &&
                    nums[k] + nums[i] >= target)
                    break;
                if (i > 0 && nums[i] == nums[i - 1] && i - k > 1)
                    continue;
                int left = i + 1;
                int right = nums.size() - 1;
                while (left < right) {
                    long long sum = nums[k]* 1LL + nums[i]* 1LL + nums[left]* 1LL + nums[right]* 1LL;
                    if (sum == target) {
                        result.push_back(
                            {nums[k], nums[i], nums[left], nums[right]});
                        while (left < right && nums[right] == nums[right - 1])
                            right--;
                        right--;
                        while (left < right && nums[left] == nums[left + 1])
                            left++;
                    } else if (sum < target) {
                        left++;
                    } else if (sum > target) {
                        right--;
                    }
                }
            }
        }
        return result;
    }

⚠️ 思维困境
除了一开始看错题目以为四元数组内数字不能重复以及坚决不用 long long 以外，还挺容易。
本题要使用 long long 否则有案例会溢出；剪枝操作如下：有必要增加 nums[ k ] != 0 的判断条件，因为特殊情况 target = 0 时，[ 0, 0, 0, 0 ] 是满足题目要求的。

if (target >= 0 && nums[k] != 0 && nums[k] >= target)
    break;

另外一个细节是： i - k > 1 是防止 i 和 k 相同时，两数挨着而 k 被误认为是遍历过的 i - 1 被跳过。

if (i > 0 && nums[i] == nums[i - 1] && i - k > 1)
    continue;

🔍 复杂度分析
时间：O(N^3) 
空间：O(1) 

📌 今日总结
其实我就是这样的人表面上跟你嘻嘻哈哈实际上内心比谁都嘻嘻哈哈我可以跟你嘻嘻哈哈但你要是敢跟我嘻嘻哈哈的话我肯定跟你嘻嘻哈哈。
哈哈。

💎补充知识点

 版权声明：本文由Cpp补兑称原创，转载请注明出处