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

Yoga_777

已于 2023-01-18 14:49:45 修改

阅读量165

点赞数

文章标签：算法哈希算法 leetcode

于 2023-01-17 22:31:27 首次发布

本文链接：https://blog.csdn.net/m0_62987089/article/details/128716900

版权

顺序：
1.先自己敲代码发现不会
2.看思路题解，不要看具体代码
3.再敲，看能不能通过，找问题
4.发现还是不想，对比看具体代码

454.四数相加II

题目链接/文章讲解/视频讲解：https://programmercarl.com/0454.%E5%9B%9B%E6%95%B0%E7%9B%B8%E5%8A%A0II.html

想法

没有想法

哈希表法

和为某个数的题看看可不可以用哈希表法

首先定义一个unordered_map，key放a和b两数之和，value 放a和b两数之和出现的次数。

遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中。

定义int变量count，用来统计 a+b+c+d = 0 出现的次数。

在遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。

最后返回统计值 count 就可以了

class Solution {
public:
    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
        unordered_map<int, int> umap; //key:a+b的数值，value:a+b数值出现的次数
        // 遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中
        for (int a : A) {
            for (int b : B) {
                umap[a + b]++;
            }
        }
        int count = 0; // 统计a+b+c+d = 0 出现的次数
        // 在遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就把map中key对应的value也就是出现次数统计出来。
        for (int c : C) {
            for (int d : D) {
                if (umap.find(0 - (c + d)) != umap.end()) {
                    count += umap[0 - (c + d)];
                }
            }
        }
        return count;
    }
};

383. 赎金信

题目链接/文章讲解：https://programmercarl.com/0383.%E8%B5%8E%E9%87%91%E4%BF%A1.html

想法

bool canConstruct(char * ransomNote, char * magazine){
    int hash[26]={0};
    int i;
    for(i=0;ransomNote+i!=NULL;i++){
        hash[ransomNote[i]-'a']++;
    }
    for(i=0;magazine+i!=NULL;i++){
        hash[magazine[i]-'a']--;
    }
    for(i=0;i<26;i++){
        if(hash[i]>0)
        return false;
    }
    return true;

}

错误

数组最后的/0在leetcode（不知道是不是所有编译器）被看成了空格，然后与‘a’的ASCII码相减后成为-97，数组越界
将其临界条件改为strlen(randomnote)后通过编译

bool canConstruct(char * ransomNote, char * magazine){
    int hash[26]={0};
    int i;
    for(i=0;i<strlen(ransomNote);i++){
       hash[ransomNote[i]-'a']++;
    }
    for(i=0;i<strlen(magazine);i++){
         hash[magazine[i]-'a']--;
    }
    for(i=0;i<26;i++){
        if(hash[i]>0)
        return false;
    }
    return true;

}

15. 三数之和

题目链接/文章讲解/视频讲解：https://programmercarl.com/0015.%E4%B8%89%E6%95%B0%E4%B9%8B%E5%92%8C.html

想法

没有想法

解法

双指针法

在这里插入图片描述
拿这个nums数组来举例，首先将数组排序，然后有一层for循环，i从下标0的地方开始，同时定一个下标left 定义在i+1的位置上，定义下标right 在数组结尾的位置上。

依然还是在数组中找到 abc 使得a + b +c =0，我们这里相当于 a = nums[i]，b = nums[left]，c = nums[right]。

接下来如何移动left 和right呢，如果nums[i] + nums[left] + nums[right] > 0 就说明此时三数之和大了，因为数组是排序后了，所以right下标就应该向左移动，这样才能让三数之和小一些。

如果 nums[i] + nums[left] + nums[right] < 0 说明此时三数之和小了，left 就向右移动，才能让三数之和大一些，直到left与right相遇为止。

去重逻辑的思考

a的去重

说道去重，其实主要考虑三个数的去重。 a, b ,c, 对应的就是 nums[i]，nums[left]，nums[right]

a 如果重复了怎么办，a是nums里遍历的元素，那么应该直接跳过去。

但这里有一个问题，是判断 nums[i] 与 nums[i + 1]是否相同，还是判断 nums[i] 与 nums[i-1] 是否相同。

有同学可能想，这不都一样吗。

其实不一样！

都是和 nums[i]进行比较，是比较它的前一个，还是比较他的后一个。

如果我们的写法是这样：

if (nums[i] == nums[i + 1]) { // 去重操作
    continue;
}

那就我们就把三元组中出现重复元素的情况直接pass掉了。例如{-1, -1 ,2} 这组数据，当遍历到第一个-1 的时候，判断下一个也是-1，那这组数据就pass了。

我们要做的是不能有重复的三元组，但三元组内的元素是可以重复的！

所以这里是有两个重复的维度。

那么应该这么写：

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

这么写就是当前使用 nums[i]，我们判断前一位是不是一样的元素，在看 {-1, -1 ,2} 这组数据，当遍历到第一个 -1 的时候，只要前一位没有-1，那么 {-1, -1 ,2} 这组数据一样可以收录到结果集里。

这是一个非常细节的思考过程。

相当于前一个数已经把这个数组中所有三数等于0的可能性全部遍历了一遍了，如果后一个数与前一个数相等，那么后一个数包含在内的三数和为0的情况与前一个数的情况相同，会重复

b与c的去重

若情况为{0，-1，-1，-1，1，1，1}，right和left向中间移动时，可能出现情况都是{0，-1，1}，这样出现重复，则如果right和left移动的过程中出现下一个指向的元素值与当前元素值相等，则再向下移动一位，直到不与当前元素值相等

我看思路后写的

int** threeSum(int* nums, int numsSize, int* returnSize, int** returnColumnSizes){
    sort(nums);
    int *left;
    left=nums+1;
    int *right;
    right=nums+numsSize-1;
    int i;
    int **result=malloc(sizeof(int)*numsSize);
    int count=0;
    for(i=0;i<numsSize-2;i++){
        if(nums[i]>0)
        return NULL;
        if(i>0&&nums[i]==nums[i--]){
            continue;
        }
        if(left<right){
        if(nums[i]+nums[left]+nums[right]==0){
        result[count][0]=i;
        result[count][1]=left;
        result[count][2]=right;
        count++
        }
        else if(nums[i]+nums[left]+nums[right]>0){
            right--;
            while(nums[right]==nums[right-1]){
                right--;
            }
            left++;
            while(nums[left]==nums[left+1]){
                left++;
        }
            }
        }
        
    }
    return result;
}

错误：
1.应该是在left<right的情况下循环
2.无论是和大于小于还是等于0，都应该在三种情况下分别移动left和right只是在等于0的情况下才需要查重。

正解：

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;
            }
            // 错误去重a方法，将会漏掉-1,-1,2 这种情况
            /*
            if (nums[i] == nums[i + 1]) {
                continue;
            }
            */
            // 正确去重a方法
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            int left = i + 1;
            int right = nums.size() - 1;
            while (right > left) {
                // 去重复逻辑如果放在这里，0，0，0 的情况，可能直接导致 right<=left 了，从而漏掉了 0,0,0 这种三元组
                /*
                while (right > left && nums[right] == nums[right - 1]) right--;
                while (right > left && nums[left] == nums[left + 1]) left++;
                */
                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]});
                    // 去重逻辑应该放在找到一个三元组之后，对b 和 c去重
                    while (right > left && nums[right] == nums[right - 1]) right--;
                    while (right > left && nums[left] == nums[left + 1]) left++;

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

        }
        return result;
    }
};

18. 四数之和

题目链接/文章讲解/视频讲解：https://programmercarl.com/0018.%E5%9B%9B%E6%95%B0%E4%B9%8B%E5%92%8C.html

想法

可能跟三数之和十分类似，但是具体不知道怎么做

解法

看完思路后写的

int** fourSum(int* nums, int numsSize, int target, int* returnSize, int** returnColumnSizes){
    sort(nums);
    int k;
    int left;
    int right;
    int **result=malloc(sizeof(int)*numsSize);
    int count=0;
    int i;
    for(k=0;k<numsSize;k++){
        if(nums[k]>target&&target>=0){
            return NULL;
        }
        if(k>0&&nums[k]==nums[k-1]){
            continue;
        }
        for(i=k+1;i<numsSize;i++){
            left=i+1;
            right=numsSize-1;
            if(nums[k]+nums[i]>target&&target>=0){
                break;
            }
            if(i>k+1&&nums[i]==nums[i-1]){
                continue;
            }
            while(left<right){
            if(nums[i]+nums[left]+nums[right]==target-nums[k]){
                result[count][0]=k;
                result[count][1]=i;
                result[count][2]=left;
                result[count][3]=right;
                count++;
                left++;
                while(nums[left]==nums[left+1])
                left++;
                right--;
                while(nums[right]==nums[right--])
                right--;
            }
            else if(nums[i]+nums[left]+nums[right]>target-nums[k]){
                right--;
            }
            else left++;
        }
            }
            
    }return result;
}

错误
1.大于小于时应该考虑等号，这道题可能出现{0，0，0，0}情况，所以(nums[k]>target&&target>=0)才对，target>0不对
2.这时应该直接返回上一层，而不是continue，因为最小的都大于target而且target>=0
3.数组有[k-1]类似时，要考虑k的范围是否能使k-1>0;

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        for (int k = 0; k < nums.size(); k++) {
            // 剪枝处理
            if (nums[k] > target && nums[k] >= 0) {
            	break; // 这里使用break，统一通过最后的return返回
            }
            // 对nums[k]去重
            if (k > 0 && nums[k] == nums[k - 1]) {
                continue;
            }
            for (int i = k + 1; i < nums.size(); i++) {
                // 2级剪枝处理
                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) {
                    // nums[k] + nums[i] + nums[left] + nums[right] > target 会溢出
                    if ((long) nums[k] + nums[i] + nums[left] + nums[right] > target) {
                        right--;
                    // nums[k] + nums[i] + nums[left] + nums[right] < target 会溢出
                    } else if ((long) nums[k] + nums[i] + nums[left] + nums[right]  < target) {
                        left++;
                    } else {
                        result.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 (right > left && nums[left] == nums[left + 1]) left++;

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

            }
        }
        return result;
    }
};

Yoga_777

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫