算法题打卡day7 | 454.四数相加II、383. 赎金信、15. 三数之和、18. 四数之和

454. 四数相加 II - 力扣（LeetCode）

状态：暴力法肯定不现实，没有思路。

 这道题利用了可统计重复四元组的特点，将4个数组两两划分，这样就把时间复杂度降成。主要的思路也就是这个，具体的实现和两数之和中的方法类似。这道题的升级款是将四个数组变为一个数组nums[]，问在这个数组中有多少「不重复」四元组之和等于k值。后续有讨论会补上。

383. 赎金信 - 力扣（LeetCode）

状态：AC，和昨天的242.有效字母异位词相似。

需要注意的是后一个字符串可以比前一个字符串多，所以最后判断为false的条件应该是i > 0。时间复杂度。 

15. 三数之和 - 力扣（LeetCode）

状态：没思路。

可以用哈希表来写，但是去重的过程复杂容易有bug。更推荐使用双指针来解决。这道题去年提交过两次，不过看示例也是跟着别人思路写的，导致一年后完全没有思路，需要比螺旋矩阵更多次的练习巩固，时间复杂度，代码如下：

vector<vector<int>> threeSum(vector<int>& nums) {
    vector<vector<int>> res;
    sort(nums.begin(), nums.end());
    // 找出a + b + c = 0
    // a = nums[i], b = nums[left], c = nums[right]
    for(int i = 0; i < nums.size(); ++i){
        if(nums[i] > 0){
            return res;
        }
        //错误去重方法，将会漏掉-1, -1, 2这种情况
        /*
        if(nums[i] == nums[i + 1]){
            continue;
        }
        */
        //正确去重方法
        if(i > 0 && nums[i] == nums[i-1]){
            continue;
        }
        int left = i + 1;
        int right = nums.size() - 1;
        while(right > left){
            if(nums[i] + nums[left] + nums[right] > 0) right--;
            else if(nums[i] + nums[left] + nums[right] < 0) left++;
            else{
                res.push_back(vector<int>{nums[i], nums[left], nums[right]});
                //去重逻辑
                while(right > left && nums[right] == nums[right-1]) right--;
                while(left < right && nums[left] == nums[left+1]) left++;

                //找到答案时，双指针同时收缩
                right--;
                left++;
            }
        }
    }
    return res;
}

18. 四数之和 - 力扣（LeetCode）

状态：只能口述个大概的思路，代码无法实现。

双指针法，比三数之和多一层循环，同时剪枝条件也不一样。时间复杂度，代码如下：

vector<vector<int>> fourSum(vector<int>& nums, int target) {
    vector<vector<int>> res;
    //同样是双指针法的思路  
    sort(nums.begin(), nums.end());
    for(int k = 0; k < nums.size(); ++k){
        //剪枝处理
        if(nums[k] > target && nums[k] >= 0){
            break;
        }
        //对nums[k]去重
        if(k > 0 && nums[k] == nums[k - 1]){
            continue;
        }
        for(int i = k+1; i < nums.size(); ++i){
            //二级剪枝处理
            if(nums[k] + nums[i] > target && nums[k] + nums[i] >= 0){
                break;
            }

            //对nums[i]去重
            if(i > k+1 && nums[i] == nums[i-1]){
                continue;
            }
            int left = i + 1;
            int right = nums.size() - 1;
            while(right > left){
                if((long)nums[k] + nums[i] + nums[left] + nums[right] > target){
                    right--;
                }else if((long)nums[k] + nums[i] + nums[left] + nums[right] < target){
                    left++;
                }else{
                    res.push_back(vector<int>{nums[k], nums[i], nums[left], nums[right]});
                    //对nums[left]和nums[right]去重
                    while(right > left && nums[right] == nums[right-1]) right--;
                    while(left < right && nums[left] == nums[left+1]) left++;

                    right--;
                    left++;
                }
            }
        }
    }
    return res;
}