代码随想录第七天 454.四数相加II 383. 赎金信 15. 三数之和 18. 四数之和

LeetCode 454.四数相加II

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

• 0 <= i, j, k, l < n
• nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0、

示例 1：

输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0

示例 2：

输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
输出：1

思路：思路有点类似两数相加的思路，两数相加是先固定选择一个数，再找有没有另一个数和它相加得到目标和。这里的思路是先求两个数组的和，固定一个数，再从另外两个数组的和中找有没有相加之后得到目标和的。这道题不同的地方在于，它要求的是满足这个条件的元组的个数，而不需要求出下标，所以用map的key是它们的和，value是和出现的次数，如果需要求四个数字的下标就更加麻烦。两数之和里面key是数值，value是下标。

class Solution {
public:
    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
        unordered_map<int, int> umap;
        for(int a:A){
            for(int b:B){
                umap[a + b]++;
            }
        }
        int count = 0;
        for(int c:C){
            for(int d:D){
                if(umap.find(0-(c+d)) !=umap.end()){
                    count += umap[0-(c+d)];
                }
            }
        }
        return count;
    }
};

LeetCode 383 赎金信

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。

示例 1：

输入：ransomNote = "a", magazine = "b"
输出：false

示例 2：

输入：ransomNote = "aa", magazine = "ab"
输出：false

示例 3：

输入：ransomNote = "aa", magazine = "aab"
输出：true

思路一：暴力解法：这道题是ransomNote里面的字母是否都能在要判断

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int flag = 0;
        for (int i = 0; i < ransomNote.length(); i++) {
            for (int j = 0; j < magazine.length(); j++) {
                if (magazine[j] == ransomNote[i]) {
                    flag++;
                    magazine.erase(magazine.begin() + j); 
                    break;
                }
            }
        }
        if (flag == ransomNote.length()) {
            return true;
        }
        return false;
    }
};

思路二：首先要满足magazine的字符串长度不能小于ransomNote字符串的长度，其次，记录magazine中每一个字符出现的次数，然后和ransomNote进行比对，如果ramsomNote中有字符出现的次数更多，就返回false.

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

 LeetCode 15 三数之和

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

示例 2：

输入：nums = [0,1,1]
输出：[]
解释：唯一可能的三元组和不为 0 。

示例 3：

输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。

思路：双指针法：

1.如果要满足三个数字相加的和为0，首先第一个数一定要小于等于0。
2.为了保证结果中不出现重复的元组，首先是第一个数字不要和先前的重复，也就是说如果判断第二次循环的数字和上一次循环的数字相等（因为进行了排序，如果有相等的数字出现，一定是相邻的），那么就可以跳过这一次循环。
同样第二个数字，如果和前一个数相等，也可以跳过这一次循环

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] > 0) {
                return result;
            }
            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{
                    result.push_back(vector<int>{nums[i], nums[left], nums[right]});
                    while(right > left && nums[right] == nums[right - 1]) right--;
                    while(right > left && nums[left] == nums[left + 1]) left++;
                    right--;
                    left++;
                }
            }
        }
        return result;
    }
};

这里在nums[i]+nums[left]+nums[right] = 0的时候，才会出现有重复元组的情况，需要判断nums[right] == nums[right - 1]，如果相等，就跳过这个数字。并且在nums[i]+nums[left]+nums[right] = 0的情况下，两边的指针都要移动，因为这时候只移动一边的指针，已经不会出现满足nums[i]+nums[left]+nums[right] = 0的情况，如果出现了也需要跳过，因为重复了，所以两边的指针都向里移一位。并且nums[right] == nums[right - 1]的情况下，也要保证右边的指针不能连续移动到小于左边指针的位置

 LeetCode 18 四数之和

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

• 0 <= a, b, c, d < n
• a、b、c 和 d 互不相同
• nums[a] + nums[b] + nums[c] + nums[d] == target

你可以按 任意顺序 返回答案 。

示例 1：

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

示例 2：

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

思路：和三数之和的思路很类似，不同的是需要再嵌套一个循环，对第一次剪枝的条件也会改变，例如： 不要判断nums[k] > target 就返回了，三数之和 可以通过 nums[i] > 0 就返回了，因为 0 已经是确定的数了，四数之和这道题目 target是任意值。比如：数组是[-4, -3, -2, -1]，target是-10，不能因为-4 > -10而跳过。

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        sort(nums.begin(),nums.end());
        for(int i = 0;i < nums.size();i++){
            if(nums[i] > target && (nums[i] >=0 || target >= 0)){
                return result;
            }
            if(i > 0 && nums[i]==nums[i-1]){
                continue;
            }
            for(int j = i+1;j<nums.size();j++){
                
                if(j > i+1 && nums[j]==nums[j-1]){
                continue;
                }
                int left = j+1;
                int right = nums.size()-1;
                while(left < right){
                    if((long)nums[i]+nums[j]+nums[left]+nums[right]> target) right--;
                    else if((long)nums[i]+nums[j]+nums[left]+nums[right] < target) left++;
                    else{
                        result.push_back(vector<int>{nums[i],nums[j], nums[left], nums[right]});
                        while(right > left && nums[right] == nums[right - 1]) right--;
                        while(right > left && nums[left] == nums[left + 1]) left++;
                        right--;
                        left++;
                    }
                }
            }
        }
        return result;
    }
};

 这里要注意的是

nums[k] + nums[i] + nums[left] + nums[right] > target 会溢出

 

所以前面需要加一个长整型的符号