目录
下决心转c++, 所以后面代码优先用c++写
454.四数相加II
建议：本题是 使用map 巧妙解决的问题，好好体会一下 哈希法 如何提高程序执行效率，降低时间复杂度，当然使用哈希法 会提高空间复杂度，但一般来说我们都是舍空间换时间， 工业开发也是这样。
题目链接/文章讲解/视频讲解：代码随想录
第一想法
没有什么想法，只能四个for循环
代码随想录
思路：
map中存放的key: A+B; value： 出现的次数。四个数分为两组，每个组遍历
这道题目是四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不用考虑有重复的四个元素相加等于0的情况
解题步骤：
1. 定义一个unordered_map, key放a和b两数之和，value放a和b两数之和出现的次数
2. 遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中
3. 定义int 变量count，统计a+b+c+d=0的次数
4. 遍历大C和大D数组，找到0-(c+d)如果在map中出现过的画，就用count把map中key对应的value也就是出现次数统计出来
5. 返回统计值count
注意点：
1. c++ map创建方法
unordered_map<int, int> umap;2. c++ map查找元素的方法
umap.find(x)代码：
c++
class Solution {
public:
int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
unordered_map<int, int> umap;
for (int a : nums1){
for (int b:nums2){
umap[a+b] ++;
}
}
int count = 0;
for (int c: nums3){
for (int d: nums4){
if(umap.find(0-(c+d)) != umap.end()){
count += umap[0-(c+d)];
}
}
}
return count;
}
};python
class Solution:
def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
umap = dict()
for a in nums1:
for b in nums2:
if (a+b) in umap:
umap[a+b] += 1
else:
umap[a+b] = 1
count = 0
for c in nums3:
for d in nums4:
if ((0-(c+d) in umap)):
count += umap[(0-(c+d))]
return count- 时间复杂度: O(n^2)
- 空间复杂度: O(n^2)，最坏情况下A和B的值各不相同，相加产生的数字个数为 n^2
383. 赎金信
建议：本题 和 242.有效的字母异位词 是一个思路 ，算是拓展题
题目链接/文章讲解：代码随想录
第一想法
用map存放magazine中的字母的个数，再遍历ransomNote，判断每个字母是否在map中且个数不为零，如果存在，则个数减一，否则返回False
c++试了一下失败了，python代码倒是通过了
class Solution:
def canConstruct(self, ransomNote: str, magazine: str) -> bool:
res = dict()
for s in magazine:
if s in res:
res[s]+=1
else:
res[s] = 1
for s in ransomNote:
if s in res and res[s] != 0:
res[s] -= 1
else:
return False
return True代码随想录
暴力枚举法：判断两个字符串中每一个字符是否相等，如果magazine中的字符在ransomNote中找到了，则在ransomNote中删除，退出内层循环。最后判断ransomNote是否为空，为空则说明可以组成
哈希法：
哈希法和我的想法是一致的，python用defaultdict或数组可能更方便一点
defaultdict的引用，创建，和获取数据方法：
from collections import defaultdict
hashmap = defaultdict(int)
value = hashmap.get(x)由于map的空间消耗比数组大，map要维护红黑树或者哈希表，还要做哈希函数，比较费时
用大小为26的数组来存储字符出现的次数
数组创建方法
int record[26] = {0};代码：
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.length(); i++){
record[magazine[i]-'a']++;
}
for (int j=0; j < ransomNote.length(); j++){
record[ransomNote[j]-'a']--;
if (record[ransomNote[j]-'a'] < 0){
return false;
}
}
return true;
}
};15. 三数之和
建议：本题虽然和 两数之和 很像，也能用哈希法，但用哈希法会很麻烦，双指针法才是正解，可以先看视频理解一下 双指针法的思路，文章中讲解的，没问题 哈希法很麻烦。
题目链接/文章讲解/视频讲解：代码随想录
第一想法
两层循环+哈希表，但是题目要求不可以包含重复的三元组
代码随想录
用双指针法
1. 首先将数组排序，然后用一层for循环，i从0开始，left在i+1, right在结尾位置
如果nums[i]+nums[left]+nums[right] > 0 说明此时三数之和大了。则right应该向左移动。
如果nums[i]+nums[left]+nums[right] < 0 说明此时三数之和小了。则left应该向右移动。
截止条件：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]});
while(right > left && nums[right] == nums[right-1]) right--;
while(right > left && nums[left] == nums[left+1]) left ++;
right--;
left++;
}
}
}
return result
}
};python 代码
def threeSum(self, nums: List[int]) -> List[List[int]]:
nums.sort()
result = []
for i in range(len(nums)):
if(nums[i] > 0):
return result
if (i > 0) and (nums[i] == nums[i-1]):
continue
print(21)
left = i + 1
right = len(nums)-1
while(left < right):
if (nums[i] + nums[left] + nums[right] > 0):
right -= 1
elif(nums[i] + nums[left] + nums[right] < 0):
left += 1
else:
result.append([nums[i], nums[left], nums[right]])
while((left < right) and (nums[left] == nums[left+1])):
left += 1
while((left < right) and (nums[right] == nums[right - 1])):
right -= 1
left += 1
right -= 1
return result- 时间复杂度: O(n^2)
- 空间复杂度: O(1)
18. 四数之和
建议： 要比较一下，本题和 454.四数相加II 的区别，为什么 454.四数相加II 会简单很多，这个想明白了，对本题理解就深刻了。 本题 思路整体和 三数之和一样的，都是双指针，但写的时候 有很多小细节，需要注意，建议先看视频。
题目链接/文章讲解/视频讲解：代码随想录
第一想法
无
代码随想录
在三数之和的基础上套一层for循环
需要注意的点：
排序后的数组需要判断
需要第一个数大于目标值且第一个值大于0，或目标值大于0. 这是由于目标值可能是负数。
nums[i]>target && (nums[i]>=0 || target >= 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;c++
}
// 对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;
}python代码
class Solution:
def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
nums.sort()
n = len(nums)
result = []
for i in range(n):
if nums[i] > target and nums[i] > 0 and target > 0:# 剪枝（可省）
break
if i > 0 and nums[i] == nums[i-1]:# 去重
continue
for j in range(i+1, n):
if nums[i] + nums[j] > target and target > 0: #剪枝（可省）
break
if j > i+1 and nums[j] == nums[j-1]: # 去重
continue
left, right = j+1, n-1
while left < right:
s = nums[i] + nums[j] + nums[left] + nums[right]
if s == target:
result.append([nums[i], nums[j], nums[left], nums[right]])
while left < right and nums[left] == nums[left+1]:
left += 1
while left < right and nums[right] == nums[right-1]:
right -= 1
left += 1
right -= 1
elif s < target:
left += 1
else:
right -= 1
return result
330
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
