四数相加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 。
例如:
输入:
- A = [ 1, 2]
- B = [-2,-1]
- C = [-1, 2]
- D = [ 0, 2]
输出:
2
解释:
两个元组如下:
- (0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
- (1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0
解题思路
总体思路
- 首先选择合适的数据结构,通过分析题意我们可以将四个数组中分别取一个值累加为0这个条件转换为分别数组c和数组d中找到两个数值c,d,满足两数之和符合0-(a+b),符合从XX中找到满足XX条件这一情况,因此可以选用哈希表进行解析,因为两数之和可能会出现相同的值,因此还需要一个位置来存放出现的次数,因此可以选用unordered_map
- 定义一个unordered_map,key用于存放两个数组中的元素累加和,value用于存放累加和出现的次数
- 首先遍历a,b数组,将累加和次数保存到umap中,然后遍历c,d数组,找到满足umap[0-(c+d)]的值,定义一个计数器加上umap[0-(c+d)]对应的value值
- 返回计数器的值即可
时空复杂度分析:
- 时间复杂度: O(n^2)
- 空间复杂度: O(n^2),最坏情况下A和B的值各不相同,相加产生的数字个数为 n^2
代码实现
测试地址:https://leetcode.cn/problems/4sum-ii/description/
class Solution {
public:
int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3,
vector<int>& nums4) {
int count = 0;
unordered_map<int, int> umap; //key:a+b的数值,value:a+b数值出现的次数
for (int a : nums1) {
for (int b : nums2) {
// 遍历大A和大B数组,统计两个数组元素之和,和出现的次数,放到map中
umap[a + b]++;
}
}
for (int c : nums3) {
for (int d : nums4) {
// 在遍历大C和大D数组,找到如果 0-(c+d) 在map中出现过的话,就把map中key对应的value也就是出现次数统计出来。
if (umap.find(0 - (c + d)) != umap.end()) {
count += umap[0 - (c + d)];
}
}
}
return count;
}
};
赎金信
题目描述
给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串,判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成,返回 true ;否则返回 false。
(题目说明:为了不暴露赎金信字迹,要从杂志上搜索各个需要的字母,组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)
注意:
你可以假设两个字符串均只含有小写字母。
canConstruct(“a”, “b”) -> false
canConstruct(“aa”, “ab”) -> false
canConstruct(“aa”, “aab”) -> true
解题思路
总体思路
- 通过分析题意可以得到因为magazines需要包含ransom中的所有字符,因此magazines的长度必定>=ransom,字符均为小写,且magazines中的字符不能重复使用,由于范围可控,因此可以使用数组进行解题
- 定义一个数组record,初始化为0,大小为26,用于存储magazines中出现的所有字符
- 判断magazines的长度是否大于ransom的长度,如果小于,直接返回false
- 遍历ransom字符串,找record数组中寻找所需字符是否足够充足,如果都能找到的话就返回true,否则返回false
时空分析:
- 时间复杂度: O(n)
- 空间复杂度: O(1)
代码实现
测试地址:
class Solution {
public:
bool canConstruct(string ransomNote, string magazine) {
int record[26] = {0}; //数组初始化为0
if (ransomNote.length() > magazine.length()) {
return false;
}
for (int i = 0; i < magazine.length(); i++) {
// 通过record数据记录 magazine里各个字符出现次数
record[magazine[i] - 'a']++;
}
for (int i = 0; i < ransomNote.length(); i++) {
// 遍历ransomNote,在record里对应的字符个数做--操作
record[ransomNote[i] - 'a']--;
// 如果小于零说明ransomNote里出现的字符,magazine不够用了
if (record[ransomNote[i] - 'a'] < 0) {
return false;
}
}
return true;
}
};
三数之和
题目描述
给你一个包含 n 个整数的数组 nums,判断 nums 中是否存在三个元素 a,b,c ,使得 a + b + c = 0 ?请你找出所有满足条件且不重复的三元组。
注意: 答案中不可以包含重复的三元组。
示例:
给定数组 nums = [-1, 0, 1, 2, -1, -4],
满足要求的三元组集合为: [ [-1, 0, 1], [-1, -1, 2] ]
解题思路
双指针思路
总体思路
-
分析题意可知,我们需要同时对数组内的三个元素累加和进行判断,因此可以使用双指针思路,引入left和right指针,将数组进行排序后,将left指向i+1位置,right执行n-1位置,依次判断i + left +right 指向元素之和是否等于0,不断移动left和right指针到合适为止,去重后,添加进结果集。
-
边界条件判断
- 由于数组有序,如果nums[i] > 0,那么三数之和必定大于0,因此直接返回0
- 如果i + left + right > 0,说明right大了,因此需要right–
- 如果i + left + right < 0 ,说明left小了,需要left++
-
去重操作
- 如果 num[i] = num[i-1],说明这个情况之前就已经考虑过了,直接continue
- 如果 num[left] = num[left+1],left++
- 如果num[right] = num[right-1],rigÏht–
时空分析:
- 时间复杂度: O(n^2)
- 空间复杂度: O(1)
代码实现
测试地址:https://leetcode.cn/problems/3sum/description/
双指针法:
class Solution {
public:
// 函数threeSum用于找到数组中所有和为0的三元组
vector<vector<int>> threeSum(vector<int>& nums) {
vector<vector<int>> result; // 存储结果的二维向量
sort(nums.begin(), nums.end()); // 对数组进行排序
// 遍历数组
for (int i = 0; i < nums.size(); i++) {
// 如果当前元素大于0,由于数组已排序,后续元素必然大于0,无法形成和为0的三元组
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) {
// 如果三数之和大于0,右指针左移
if (nums[i] + nums[left] + nums[right] > 0) {
right--;
}
// 如果三数之和小于0,左指针右移
else if (nums[i] + nums[left] + nums[right] < 0) {
left++;
}
// 如果找到和为0的三元组
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; // 返回所有找到的三元组
}
};
哈希法:
class Solution {
public:
vector<vector<int>> threeSum(vector<int>& nums) {
vector<vector<int>> result; // 存储结果的二维向量
sort(nums.begin(), nums.end()); // 对输入的数组进行排序
// 找出a + b + c = 0
// a = nums[i], b = nums[j], c = -(a + b)
for (int i = 0; i < nums.size(); i++) {
// 排序之后如果第一个元素已经大于零,那么不可能凑成三元组
if (nums[i] > 0) {
break; // 如果当前元素大于0,则后续元素不可能与它组成和为0的三元组,直接退出循环
}
if (i > 0 && nums[i] == nums[i - 1]) { // 三元组元素a去重
continue; // 如果当前元素与前一个元素相同,则跳过,避免重复的三元组
}
unordered_set<int> set; // 用于存储已检查过的元素,避免重复
for (int j = i + 1; j < nums.size(); j++) {
if (j > i + 2
&& nums[j] == nums[j-1]
&& nums[j-1] == nums[j-2]) { // 三元组元素b去重
continue; // 如果当前元素与前两个元素相同,则跳过,避免重复的三元组
}
int c = 0 - (nums[i] + nums[j]); // 计算c的值
if (set.find(c) != set.end()) {
result.push_back({nums[i], nums[j], c}); // 如果c在set中,说明找到了一个有效的三元组
set.erase(c); // 从set中移除c,避免重复记录
} else {
set.insert(nums[j]); // 如果c不在set中,将当前元素b插入set
}
}
}
return result; // 返回结果
}
};
四数之和
题目描述
题意:给定一个包含 n 个整数的数组 nums 和一个目标值 target,判断 nums 中是否存在四个元素 a,b,c 和 d ,使得 a + b + c + d 的值与 target 相等?找出所有满足条件且不重复的四元组。
注意:
答案中不可以包含重复的四元组。
示例: 给定数组 nums = [1, 0, -1, 0, -2, 2],和 target = 0。 满足要求的四元组集合为: [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]
解题思路
总体思路
本题核心解题思路和((20240531101912-jee2kn5 ‘三数之和’))类似,都可以使用双指针法进行解题,需要重点关注以下几个剪枝逻辑:
- 由于target是任意数值,当target和num[k]均为负数的时候,四数相加后的值就可能等于target,因此不是单单判断num[k] > target,例如数组是
[-4, -3, -2, -1]
,target
是-10
,不能因为-4 > -10
而跳过。需要判断target和num[k]是否非负。 - 如果前两个数值之和大于target,且targe和前两数之和均大于0,说明四数之和已经不可能等于targe了,可以直接进行剪枝操作。
时空分析:
- 时间复杂度: O(n^3)
- 空间复杂度: O(1)
代码实现
测试地址:https://leetcode.cn/problems/4sum/
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;
}
// 去重:如果当前数与前一个数相同,则跳过
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;
}
// 去重:如果当前数与前一个数相同,则跳过
if (i > k + 1 && nums[i] == nums[i - 1]) {
continue;
}
int left = i + 1; // 左指针从i的下一个位置开始
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 {
// 如果和等于目标值,记录结果
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; // 返回结果
}
};