代码随想录算法训练营第七天 | 454.四数相加ii 383.赎金信 15.三数之和 18.四数之和 ACM格式 C++

最新推荐文章于 2024-07-25 11:27:31 发布

溯源泮

最新推荐文章于 2024-07-25 11:27:31 发布

阅读量1.9k

点赞数 35

文章标签：算法 c++ 开发语言

本文链接：https://blog.csdn.net/baidu_41091186/article/details/137611548

版权

454.四数相加ii

给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。

为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -2^28 到 2^28 - 1 之间，最终结果不会超过 2^31 - 1 。

#include<iostream>
#include<vector>
#include<unordered_map>
#include<algorithm>
using namespace std ;

class Solution {
public:
	int sumFourCount(vector<int>&nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4, int target) {
		unordered_map<int, int> umap;
		for (int num1 : nums1) {
			for (int num2 : nums2) {
				umap[(num1 + num2)]++;
			}
		}
		int count = 0;
		for (int num3 : nums3) {
			for (int num4 : nums4) {
				if (umap.find(target - (num3 + num4)) != umap.end()) {
					count += umap[(target - (num3 + num4))];
				}
			}
		}
		return count;
	}

};

int main() {
	
	Solution solution;
	vector<int> nums1 = { 1, 2 };
	vector<int> nums2 = { -2, -1 };
	vector<int> nums3 = { -1, 2 };
	vector<int> nums4 = { 0, 2 };
	int target = 0;
	int a = solution.sumFourCount(nums1, nums2, nums3, nums4,target);
	cout << a << endl;
	return 0;
}

383.赎金信

给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。

(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)

数组法：

#include <iostream>
#include <vector>
#include <unordered_set>
#include <algorithm>

using namespace std;

class Solution {
public:
    bool canConstruct(string ransom, string magazine) {
        int regard[26] = { 0 };
        for (int i = 0; i < ransom.length(); i++) {
            regard[ransom[i] - 'a']++;
        }
        for (int j = 0; j < magazine.length(); j++) {
            regard[magazine[j] - 'a']--;
        }
        for (int k = 0; k < 26; k++) {
            if (regard[k] > 0) {
                return false;
            }
        }
        return true;
    }
};

// 主函数
int main() {
    Solution solution;
    string ransom = "aa";
    string magazine = "ab";
    bool a = solution.canConstruct(ransom, magazine);
    cout << a ? "true" : "false";
    return 0;
}

在std::string和相关字符串类中，size()和length()没有区别，都是返回字符串的长度。
在其他容器类（如std::vector, std::list, 等）中，只有size()函数用来返回容器中元素的数量。

暴力解法：

#include <iostream>
#include <vector>
#include <unordered_set>
#include <algorithm>

using namespace std;

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

// 主函数
int main() {
    Solution solution;
    string ransom = "aa";
    string magazine = "ab";
    bool a = solution.canConstruct(ransom, magazine);
    cout << a ? "true" : "false";
    return 0;
}

std::string的erase用法

对于字符串（std::string），erase可以以几种方式使用：

删除特定位置的字符:

std::string str = "Hello, World!";
str.erase(5, 1); // 从位置5开始删除1个字符，结果："Hello World!"

删除指定位置到字符串末尾:

str.erase(5); // 删除位置5及其之后的所有字符，结果："Hello"

使用迭代器删除单个字符或一段字符:

str.erase(str.begin() + 5); // 删除位置5的字符
str.erase(str.begin() + 5, str.end() - 5); // 从位置5开始删除到倒数第5个字符之前的部分

std::vector, std::list, 和其他序列容器的erase用法

对于std::vector、std::list等容器，erase用法主要是基于迭代器：

std::vector<int> v = {1, 2, 3, 4, 5};
v.erase(v.begin() + 2); // 删除第三个元素（值为3），结果：{1, 2, 4, 5}

删除一段元素:

v.erase(v.begin() + 1, v.begin() + 3); // 删除第二个到第三个元素（值为2和3），结果：{1, 4, 5}

对于std::vector和std::deque，使用erase删除元素会导致从删除点到容器末尾的所有元素都向前移动以填补空位，这可能会引起性能问题，尤其是在删除容器前部的元素时。而对于std::list，由于其内部实现是链表，删除元素不会引起其他元素移动，因此通常性能较好。

15.三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

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

哈希法：但有重组啊！

#include <iostream>
#include <vector>
#include <unordered_set>
#include <algorithm>

using namespace std;

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        unordered_set<int> set;
        vector<vector<int>> result;
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] > 0) {
                break;
            }
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            for (int j = i + 1; j < nums.size(); j++) {
                if (j > i + 2 && nums[j - 2] == nums[j - 1] && nums[j] == nums[j - 1]) {
                    continue;
                }
                int c = 0 - nums[i] - nums[j];
                if (set.find(c) != set.end()) {
                    result.push_back({ nums[i], nums[j], c });
                    set.erase(c);
                }
                else {
                    set.insert(nums[j]);
                }


            }

        }
        return result;
    }
};

// 主函数
int main() {
    Solution solution;
    vector<int>a = {-1, 0, 1, 2, -1, -4};
    vector<vector<int>>result =solution.threeSum(a);
    for (int i = 0; i < result.size(); i++)
    {
        for (int j = 0; j < result[i].size(); j++) {
            cout << result[i][j]<<" ";
        }
        cout << endl;
    }

    return 0;
}

双指针法：（重点是去重）

#include <iostream>
#include <vector>
#include <unordered_set>
#include <algorithm>

using namespace std;

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

// 主函数
int main() {
    Solution solution;
    vector<int>a = {-1, 0, 1, 2, -1, -4};
    vector<vector<int>>result =solution.threeSum(a);
    for (int i = 0; i < result.size(); i++)
    {
        for (int j = 0; j < result[i].size(); j++) {
            cout << result[i][j]<<" ";
        }
        cout << endl;
    }

    return 0;
}

a的去重：

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

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

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

b与c的去重：

拿right去重为例，即使不加这个去重逻辑，依然根据 while (right > left) 和 if (nums[i] + nums[left] + nums[right] > 0) 去完成right-- 的操作。

多加了 while (left < right && nums[right] == nums[right + 1]) right--; 这一行代码，其实就是把需要执行的逻辑提前执行了，但并没有减少判断的逻辑。

最直白的思考过程，就是right还是一个数一个数的减下去的，所以在哪里减的都是一样的。

所以这种去重是可以不加的。仅仅是把去重的逻辑提前了而已。

18.四数之和

题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

注意：

答案中不可以包含重复的四元组。

#include <iostream>
#include <vector>
#include <unordered_set>
#include <algorithm>

using namespace std;

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 && (target >= 0 && nums[i] >= 0)) {
                return result;
            }
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            for (int k = i + 1; k < nums.size(); k++) {
                // 2级剪枝处理
                if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {
                    break;
                }
                if (k > i + 1 && nums[k] == nums[k - 1]) {
                    continue;
                }
                int left = k + 1;
                int right = nums.size() - 1;
                while (left < right) {
                    if ((long)nums[i] + nums[k] + nums[left] + nums[right] < target)left++;
                    else if ((long)nums[i] + nums[k] + nums[left] + nums[right] > target)right--;
                    else {
                        result.push_back(vector<int>{nums[i], nums[k], nums[left], nums[right]});
                        while (left < right && nums[left] == nums[left + 1])left++;
                        while (left < right && nums[right] == nums[right - 1])right--;
                        left++;
                        right--;
                    }
                }
            }
        }
        return result;
    }
};

// 主函数
int main() {
    Solution solution;
    vector<int>a = {1, 0, -1, 0, -2, 2};
    int target = 0;
    vector<vector<int>>result =solution.fourSum(a,target);
    for (int i = 0; i < result.size(); i++)
    {
        for (int j = 0; j < result[i].size(); j++) {
            cout << result[i][j]<<" ";
        }
        cout << endl;
    }

    return 0;
}

但是有一些细节需要注意，例如：不要判断nums[k] > target 就返回了，三数之和可以通过 nums[i] > 0 就返回了，因为 0 已经是确定的数了，四数之和这道题目 target是任意值。比如：数组是[-4, -3, -2, -1]，target是-10，不能因为-4 > -10而跳过。但是我们依旧可以去做剪枝，逻辑变成nums[i] > target && (nums[i] >=0 || target >= 0)就可以了。

溯源泮

关注

35
点赞
踩
36

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营第七天 | 454.四数相加ii 383.赎金信 15.三数之和 18.四数之和 ACM格式 C++

题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？这么写就是当前使用 nums[i]，我们判断前一位是不是一样的元素，在看 {-1, -1 ,2} 这组数据，当遍历到第一个 -1 的时候，只要前一位没有-1，那么 {-1, -1 ,2} 这组数据一样可以收录到结果集里。最直白的思考过程，就是right还是一个数一个数的减下去的，所以在哪里减的都是一样的。
复制链接

扫一扫