今日更新题目:454.四数相加II,383. 赎金信,15. 三数之和,18. 四数之和
454.四数相加II
最初想法是模仿1.两数之和那样,先将四数之和拆分成两数之和,假设拆成 nums1[i] + nums2[j]
和 nums3[k] + nums4[l]
,也就是说这两部分要互为相反数,遍历nums1和nums2,在两层for循环内部寻找符合条件的 nums3[k]
和 nums4[l]
,想到这发现不对,如果我还需要分别在 nums3[k]
和 nums4[l]
找,岂不是变成了四层for循环,复杂度直接变为 O(n4) 了吗。想到这立马决定换方法,瞟了一眼代码随想录,发现不一定要选两个nums数组分别创建一个集合,完全可以创建一个两数之和的集合。
class Solution {
public:
int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
unordered_map<int, int> sum_3_4;
for(int i : nums3){
for(int j : nums4){
int sum = i + j;
sum_3_4[sum]++;
}
}
int count = 0;
for(int i : nums1){
for(int j : nums2){
int sum = i + j;
if(sum_3_4.find(0-sum) != sum_3_4.end()){
count += sum_3_4[0-sum];
}
}
}
return count;
}
};
383. 赎金信
这题其实和 242.有效的字母异位词 思路是一样的,就是先将 magazine
出现的字母次数存入 word_table
,接着遍历 ransomNote
,去 magazine
中查找是否有足够的字母组成 ransomNote
即可。由于提示中说到 ransomNote
和 magazine
由小写英文字母组成,且字母只有26个,因此选用数组,而非map(使用map的空间消耗要比数组大)。
class Solution {
public:
bool canConstruct(string ransomNote, string magazine) {
int record[26] = {0};
for(int i = 0; i < magazine.size(); i++)
record[magazine[i]-'a']++;
for(int i = 0; i < ransomNote.size(); i++){
if(record[ransomNote[i]-'a'] != 0)
record[ransomNote[i]-'a']--;
else
return false;
}
return true;
}
};
15. 三数之和
本题的基本思路是:先对数组排序,排序后做两层for循环,第一层for循环中先固定一个数nums[i],然后利用双指针法,左指针从i+1位置开始,右指针从nums.size() - 1位置开始,由于数组是经过排序的,左边小右边大,因此双指针法可以动态调整三数之和的大小:
- 当三数之和过大,则右指针自减;
- 当三数之和过小,则左指针自增
- 当三数之和为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++){
int left = i + 1;
int right = nums.size() - 1;
while(left < right){
int sum = nums[i] + nums[left] + nums[right];
if(sum > 0){
right--;
}
else if(sum < 0){
left++;
}
else{
result.push_back(vector<int>{nums[i], nums[left], nums[right]});
left++;
right--;
}
}
}
return result;
}
};
本题最容易忽略的条件不是:满足 i != j
、i != k
且 j != k
,而是答案中不可以包含重复的三元组,也就是去重问题,举个例子
输入
nums =[-2,0,0,1,1,2,2,2]
错误输出
[[-2,0,2],[-2,0,2]]
预期结果
[[-2,0,2]]
由于每一个数都是由i j k分别选出来的,所以要保证遍历过的i所对应的数值不重复,在此基础上保证遍历过的j k所对应的数值不重复,若有则直接跳过
首先对nums[i]的去重,这里就不多赘述
if(i > 0 && nums[i] == nums[i-1]){
continue;
}
然后对nums[j] 和 nums[k] 去重
while(left < right && nums[left] == nums[left + 1])
left++;
while(left < right && nums[right] == nums[right - 1])
right--;
综上,可得出最后的代码
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){
int sum = nums[i] + nums[left] + nums[right];
if(sum > 0){
right--;
}
else if(sum < 0){
left++;
}
else{
result.push_back(vector<int>{nums[i], 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;
}
};
18. 四数之和
本题和上题思路一样,只是多了一层for循环而已,需要注意的是多了一层for循环则要添加对应的去重检测
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;
}
};