今天的四道题是哈希表
先给出思路：
- 定义一个哈希表，记录nums1中的数a与nums2中的数b两两配对的和
a+b； - 随后查看nums3中的数c与nums4中的数d的和
c+d是否满足-(c+d)=a+b。 思路一目了然，重点在于解法的思路，即二分法。我们拓展一下题目：给定n个数组，求有多少个n元组(i,j,...k)满足nums1[i]+nums2[j]+...+numsn[k]=0，那么我们可以将问题转化为，即选择一个点将条件进行分割，一般是取中点。
AC代码：
class Solution {
public:
int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3,
vector<int>& nums4) {
unordered_map<long long, int> abSum;
for (int a : nums1) {
for (int b : nums2) {
abSum[a + b]++;
}
}
int count = 0;
for (int c : nums3) {
for (int d : nums4) {
if (abSum.find(-(c + d)) != abSum.end()) {
count += abSum[-(c + d)];
}
}
}
return count;
}
};
AC代码：
class Solution {
public:
bool canConstruct(string ransomNote, string magazine) {
unordered_map<char,int> magazineMap;
for(int i=0;i<magazine.length();++i){
magazineMap[magazine[i]]++;
}
for(char c:ransomNote){
if(magazineMap.find(c) == magazineMap.end()){
return false;
}
else{
if(--magazineMap[c] < 0) return false;
}
}
return true;
}
};
class Solution {
public:
bool canConstruct(string ransomNote, string magazine) {
int record[26] = {0};
//add
if (ransomNote.size() > magazine.size()) {
return false;
}
for (int i = 0; i < magazine.length(); i++) {
// 通过record数据记录 magazine里各个字符出现次数
record[magazine[i]-'a'] ++;
}
for (int j = 0; j < ransomNote.length(); j++) {
// 遍历ransomNote，在record里对应的字符个数做--操作
record[ransomNote[j]-'a']--;
// 如果小于零说明ransomNote里出现的字符，magazine没有
if(record[ransomNote[j]-'a'] < 0) {
return false;
}
}
return true;
}
};
第一眼，同一个数组，下标不重复->回溯；结果不重复->哈希；但有一个问题c++的哈希表不支持vector<int>，所以需要我们自定义一个哈希函数。这个方法会超时。
三指针法：先排序，然后定义三个指针，分别指向基准值i，左边界left，右边界right，因为已经排序，使用当三数之和nums[i]+nums[left]+nums[right]>0时，只需要移动right--；反之当nums[i]+nums[left]+nums[right]<0，移动left++；nums[i]+nums[left]+nums[right]=0时则需要对left和right去重。
AC代码：
//回溯，超时了
namespace std {
template <> struct hash<vector<int>> {
size_t operator()(const vector<int>& nums) const {
return hash<int>()(nums[0]) ^ hash<int>()(nums[1]) ^ hash<int>()(nums[2]);
}
};
} // namespace std
class Solution {
public:
unordered_set<vector<int>> ansSet;
vector<vector<int>> threeSum(vector<int>& nums) {
vector<int> path;
sort(nums.begin(), nums.end());
backtracing(nums, 0, 0, path);
vector<vector<int>> ans(ansSet.begin(), ansSet.end());
return ans;
}
void backtracing(vector<int>& nums, int startIndex, int sum,
vector<int>& path) {
if (path.size() == 3 && sum == 0) {
ansSet.emplace(vector<int>(path.begin(), path.end()));
return;
}
if (startIndex >= nums.size())
return;
for (int i = startIndex; i < nums.size(); ++i) {
if (sum + nums[i] > 0)
break;
path.push_back(nums[i]);
backtracing(nums, i + 1, sum + nums[i], path);
path.pop_back();
}
}
};
//三指针法
class Solution {
public:
vector<vector<int>> threeSum(vector<int>& nums) {
vector<vector<int>> ans;
sort(nums.begin(), nums.end());
for (int i = 0; i < nums.size(); ++i) {
// 去重
if (i > 0 && nums[i] == nums[i - 1]) {
continue;
}
int left = i + 1;
int right = nums.size() - 1;
while (left < right) {
if (nums[i] + nums[left] + nums[right] > 0) right--;
else if (nums[i] + nums[left] + nums[right] < 0) left++;
else {
ans.push_back(vector<int>{nums[i], nums[left], nums[right]});
//去重
while (left < right && nums[right] == nums[right - 1]) right--;
while (left < right && nums[left] == nums[left + 1]) left++;
left++;
right--;
}
}
}
return ans;
}
};
和三数之和类似，只是多了一层循环。注意可能会超int的范围，在计算四数相加时要转为long。
与454. 四数相加 II不同的地方在于，本题目要求下标不能有重复且答案也不能有重复，因此不适合哈希表
而对于15.三数之和双指针法就是将原本暴力O(n^3)的解法，降为O(n^2)的解法，四数之和的双指针解法就是将原本暴力O(n^4)的解法，降为O(n^3)的解法。
class Solution {
public:
vector<vector<int>> fourSum(vector<int>& nums, int target) {
vector<vector<int>> ans;
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;
int right = nums.size() - 1;
while (left < right) {
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 {
ans.push_back(vector<int>{nums[k], nums[i], nums[left],
nums[right]});
// 去重
while (left < right && nums[right] == nums[right - 1])
right--;
while (left < right && nums[left] == nums[left + 1])
left++;
left++;
right--;
}
}
}
}
return ans;
}
};
