代码随想录算法训练营
—day7
前言
今天是算法营的第7天，希望自己能够坚持下来！
今日任务：
● 454.四数相加II
● 383. 赎金信
● 15. 三数之和
● 18. 四数之和
● 总结
一、454.四数相加II
思路：
1.因为是四个独立的数组，不需要考虑有重复的四元组。考虑用哈希表存相加结果；
2.因为求的是多少个，所以需要保存相加结果出现的次数，考虑使用map；
3.用map存放AB数组，元素相加的结果和次数；
4.两个for遍历CD数组，依次判断0-c+d在另一个map是否有满足的元素；
5.把满足结果对应的元素出现的次数累加得出最终结果。
(此处需要注意跟四数之和作对比，四数之和因为只提供了一个数组，且需要去重，所以用双指针会比哈希表更好写)
代码如下：
class Solution {
public:
int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
unordered_map<int,int> map; //key：数组num1+num2的值，value：num1+num2出现的次数
int count = 0;
//遍历数组nums1和nums2，统计元素之和，出现的次数，存放在map中
for (int num1:nums1) {
for (int num2:nums2) {
map[num1+num2]++;
}
}
//遍历数组nums3和nums4，查找0-(num3+num4)在map中是否出现过，
//并且累加对应的出现次数value
for (int num3:nums3) {
for (int num4:nums4) {
int target = 0 - (num3+num4);
if (map.find(target) != map.end()) {
count += map[target];
}
}
}
return count;
}
};
二、383. 赎金信
思路：
这道题跟242.有效的字母异位词很像，这里是求第二个字符串magazines的字母能不能组成第一个字符串ransom
1.记录字母出现的次数，且只有小写字母，最多只有26个，优先使用数组
2.遍历第二个字符串magazines，记录每个字符串出现的次数
3.遍历第一个字符串ransom，将map中对应的字符出现次数–
4.若次数小于0，则认为结果为false
一开始我的第一反应确实是想使用map，因为需要记录次数还有字符两个信息。
但是看讲解上说，在本题的情况下，使用map的空间消耗要比数组大一些的，因为map要维护红黑树或者哈希表，而且还要做哈希函数，是费时的。数据量大的话就能体现出来差别了。 所以数组更加简单直接有效！
代码如下：
class Solution {
public:
bool canConstruct(string ransomNote, string magazine) {
int record[26] = {0};
if (ransomNote.size() > magazine.size()) {
return false;
}
for(int i=0; i < magazine.size(); i++) {
//记录magazine中每个字符出现的次数
record[magazine[i] - 'a']++;
}
for(int i=0; i< ransomNote.size(); i++) {
//遍历ransomNote，在record里对应的字符个数做--
if (record[ransomNote[i] - 'a'] > 0) {
record[ransomNote[i] - 'a']--;
} else {
return false;
}
}
return true;
}
};
三、15. 三数之和
思路：
方法1：哈希表
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;
}
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]);
if (set.find(c) != set.end()) {
result.push_back({nums[i], nums[j], c});
set.erase(c);// 三元组元素c去重
} else {
set.insert(nums[j]);
}
}
}
return result;
}
};
方法2：双指针
思路：
1.题目不要求元素的顺序，所以可以对元素进行排列，对有序数组可以用双指针法
2.定义left和right，用i遍历数组,根据三数之和的大小去缩进left和right
2.这里需要对nums[i]做剪枝操作，如果nums[i]>0则后面加上nums[left]+nums[right]不可能等于0，可以直接返回了
3.判断nums[i]+nums[left]+nums[right]，
- 若>0,则ritht–；
- 若<0,则left++；
- 若=0，则将三元组存入结果vector中。
4.需要考虑i，left，right对应元素的去重：
-
i:需要跟i-1的元素做比较，因为i-1是上一个结果的三元组，要跟三元组去重；如果跟i+1做比较，就相当于在三元组内，元素之间去重，意义不一样。
-
left和right：需要跟left+1和right-1做比较，因为在循环中，i是固定的，如果left+1跟left相等的话，那么找到符合条件的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 (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
//因为现在nums[i]固定了，如果nums[right]还是一样，
//那么nums[left]也会是一样的，最后结果三元组就会重复
while (right > left && nums[right] == nums[right - 1]) right--;
while (right > left && nums[left] == nums[left + 1]) left++;
left++;
right--;
}
}
}
return result;
}
};
四、18. 四数之和
思路：
1.四数之和就是在三数之和的外面再套一层for循环。
2.两层for循环nums[k] + nums[i]为确定值
3.循环内有left和right下标作为双指针，找出nums[k] + nums[i] + nums[left] + nums[right] == target的情况，
（三数之和的时间复杂度是O(n^2) ， 四数之和的时间复杂度是O(n^3)）
一样的道理，五数之和、六数之和等等都采用这种解法。
代码如下：
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++) {
//k的剪枝处理，如果nums[k]是负数的话，会存在越加越小的情况
if (nums[k] >= 0 && nums[k] > target) {
break;
}
//对nums[k]去重
if (k > 0 && nums[k] == nums[k-1]) {
continue;
}
//遍历i
for (int i = k + 1; i < nums.size(); i++) {
//i的剪枝处理
if (nums[k] + nums[i] >= 0 && nums[k] + nums[i] > target) {
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) {
//不加long的话会溢出
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[right]和nums[left]去重
while (right > left && nums[right] == nums[right - 1]) right--;
while (right > left && nums[left] == nums[left + 1]) left++;
//找到答案后，双指针同时收缩
right--;
left++;
}
}
}
}
return result;
}
};
总结
今天主要是学习了：
1.观察题目是否有顺序要求，没有要求的话还可以考虑使用sort将数组排序，然后使用双指针
2.map虽然万能，但如果像题目只包含小写字母，可以优先用数组。
明天继续加油！
扫一扫
1101
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
