目录
要快速判断一个元素是否出现集合里的时候,就要考虑哈希法。
哈希法也是牺牲了空间换取了时间,因为我们要使用额外的数组,set或者是map来存放数据,才能实现快速的查找。
哈希表的实现,有三种方式:
数组,集合(set),映射(map);
数组,没什么好讲的。
集合:
当我们要使用集合来解决哈希问题的时候,优先使用unordered_set,因为它的查询和增删效率是最优的,如果需要集合是有序的,那么就用set,如果要求不仅有序还要有重复数据的话,那么就用multiset。
映射:
那么再来看一下map ,在map 是一个key value 的数据结构,map中,对key是有限制,对value没有限制的,因为key的存储方式使用红黑树实现的。
242:有效字母异位词;
class Solution {
public:
bool isAnagram(string s, string t) {
int record[26] = {0};
for(int i =0 ; i<s.size();i++){
record[s[i] - 'a']++;
}
for(int j =0;j<t.size();j++){
record[t[j] - 'a']--;
}
for(int i = 0;i<26;i++){
if(record[i] != 0) return false;
}
return true;
}
};
错误点:
- 忘记 减 ‘a';
- C++ 中的 true 和 false 是小写,不是python 中的大写。
383: 赎金信
class Solution {
public:
bool canConstruct(string ransomNote, string magazine) {
int recordA[26] = {0};
int recordB[26] = {0};
for(int i =0;i<ransomNote.size();i++){
recordA[ransomNote[i] - 'a']++;
}
for(int j = 0;j<magazine.size();j++){
recordB[magazine[j] - 'a']++;
}
for(int i = 0 ; i<26;i++){
if(recordA[i] > recordB[i]){
return false;
}
}
return true;
}
};
错误点:这题没有错误,原因:过于简单。
49:字母异位词分组;
题目:
思路1:排序
由于互为字母异位词的两个字符串包含的字母相同,因此对两个字符串分别进行排序之后得到的字符串一定是相同的,故可以将排序之后的字符串作为哈希表的键。
class Solution {
public:
vector<vector<string>> groupAnagrams(vector<string>& strs) {
unordered_map<string, vector<string>> mp;
for (string& str: strs) {
string key = str;
sort(key.begin(), key.end());
mp[key].emplace_back(str);
}
vector<vector<string>> ans;
for (auto it = mp.begin(); it != mp.end(); ++it) {
ans.emplace_back(it->second);
}
return ans;
}
};
看不太懂代码;
看懂了,看懂了!!!!
思路二:计数
由于互为字母异位词的两个字符串包含的字母相同,因此两个字符串中的相同字母出现的次数一定是相同的,故可以将每个字母出现的次数使用字符串表示,作为哈希表的键。
由于字符串只包含小写字母,因此对于每个字符串,可以使用长度为 26 的数组记录每个字母出现的次数。需要注意的是,在使用数组作为哈希表的键时,不同语言的支持程度不同,因此不同语言的实现方式也不同。
class Solution {
public:
vector<vector<string>> groupAnagrams(vector<string>& strs) {
// 自定义对 array<int, 26> 类型的哈希函数
auto arrayHash = [fn = hash<int>{}] (const array<int, 26>& arr) -> size_t {
return accumulate(arr.begin(), arr.end(), 0u, [&](size_t acc, int num) {
return (acc << 1) ^ fn(num);
});
};
unordered_map<array<int, 26>, vector<string>, decltype(arrayHash)> mp(0, arrayHash);
for (string& str: strs) {
array<int, 26> counts{};
int length = str.length();
for (int i = 0; i < length; ++i) {
counts[str[i] - 'a'] ++;
}
mp[counts].emplace_back(str);
}
vector<vector<string>> ans;
for (auto it = mp.begin(); it != mp.end(); ++it) {
ans.emplace_back(it->second);
}
return ans;
}
};
看不懂,看不懂!!!!!
349: 两个数组的交集
题目:
思路:主要要学会使用一种哈希数据结构:unordered_set,这个数据结构可以解决很多类似的问题。
unodered Set
无序集(unorder sets)是一种不按特定顺序存储唯一元素的容器,允许快速根据元素的值检索单个元素。
在unordered_set
中,元素的值同时也是唯一标识它的键。键是不可变的,因此,unordered_set
中的元素在容器中不能被修改,但是它们可以被插入和删除。
在内部,unordered_set
中的元素并不按照任何特定的顺序排序,而是根据它们的散列值组织到桶中,从而允许根据它们的值直接快速访问单个元素(平均时间复杂度为常数)。
与set容器相比,Unordered_set容器通过键访问单个元素的速度更快,尽管它们通常在通过元素的子集进行范围迭代时效率较低。
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
vector<int> ans;
unordered_set<int> A;
unordered_set<int> B (nums1.begin(),nums1.end());
for(int num : nums2){
if( B.find(num) != B.end()){
A.insert(num);
}
}
return vector<int> (A.begin(),A.end());
}
};
350:两个数组的交集 II
题目:
class Solution {
public:
vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
if(nums1.size() < nums2.size()) { return intersect( nums2 , nums1);}
unordered_map<int,int> m ;
for(int num : nums1){
m[num]++;
}
vector<int> intersection;
for(int num : nums2){
if(m.count(num)){
intersection.push_back(num);
m[num]--;
if(m[num] == 0){
m.erase(num);
}
}
}
return intersection;
}
};
注意点:
- 第四行的返回,不需要加 “ &”;
- 第十二行,为什么是呢?考虑清楚。
202: 快乐数;
题目 :
注意题目中的两个点:
第一:无限循环,意味着,中途会出现相同的数字。
第二:最后退出的数字是 1 .尤为重要。这是退出条件。
class Solution {
public:
int get_sum(int n){
int sum = 0;
while(n){
sum += (n%10)*(n%10);
n = n/10;
}
return sum;
}
bool isHappy(int n) {
unordered_set<int> A;
while(1){
int sum = get_sum(n);
if (sum == 1) return true;
if (A.find(sum) != A.end()){
return false;
}else{
A.insert(sum);
}
n = sum;
}
}
};
1.俩数之和
思路:暴力搜索
思路2:指针
map目的用来存放我们访问过的元素,因为遍历数组的时候,需要记录我们之前遍历过哪些元素和对应的下表,这样才能找到与当前元素相匹配的(也就是相加等于target)
接下来是map中key和value分别表示什么。
这道题 我们需要 给出一个元素,判断这个元素是否出现过,如果出现过,返回这个元素的下标。
那么判断元素是否出现,这个元素就要作为key,所以数组中的元素作为key,有key对应的就是value,value用来存下标。
所以 map中的存储结构为 {key:数据元素,value:数组元素对应的下表}。
在遍历数组的时候,只需要向map去查询是否有和目前遍历元素比配的数值,如果有,就找到的匹配对,如果没有,就把目前遍历的元素放进map中,因为map存放的就是我们访问过的元素。
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
std::unordered_map <int,int> map;
for(int i = 0; i < nums.size(); i++) {
// 遍历当前元素,并在map中寻找是否有匹配的key
auto iter = map.find(target - nums[i]);
if(iter != map.end()) {
return {iter->second, i};
}
// 如果没找到匹配对,就把访问过的元素和下标加入到map中
map.insert(pair<int, int>(nums[i], i));
}
return {};
}
};
454: 四数相加II
题目:
思路:上述两数相加的拓展。
class Solution {
public:
int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
unordered_map<int,int> mm;
for(int a :nums1){
for (int b :nums2){
mm[a+b]++;
}
}
int count = 0;
for(int c :nums3){
for(int d: nums4){
if(mm.find(0-c-d) != mm.end()){
count += mm[0-c-d];
}
}
}
return count;
}
};
15:三数之和
题目:
思路:利用指针; i 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;
}
};
18:四数之和
题目:
思路: 对于上述三数之和的拓展。以及N数之和,都可以这样子来弄。
class Solution {
public:
vector<vector<int>> fourSum(vector<int>& nums, int target) {
vector<vector<int>>ans;
sort(nums.begin(),nums.end());
for (int i = 0; i< nums.size() ;i++){
if(nums[i] > target && nums[i] >0){
break;
}
if(i>0 && nums[i] == nums[i-1]){
continue;
}
for(int j = i+1;j<nums.size();j++){
if(nums[i]+nums[j] > target && nums[i]+nums[j] > 0){
break;
}
if( j>i+1 && nums[j] == nums[j-1]){
continue;
}
int left = j+1;
int right = nums.size()-1;
while(left < right){
if((long) nums[i] + nums[j] + nums[left] + nums[right] > target){
right--;
}else if((long) nums[i] + nums[j] + nums[left] + nums[right] < target){
left++;
}
else{
ans.push_back(vector<int>{nums[i],nums[j],nums[left],nums[right]});
while(left < right && nums[right] == nums[right -1]){
right--;
}
while(left < right && nums[left] == nums[left+1]){
left++;
}
right--;
left++;
}
}
}
}
return ans;
}
};
错误点:
为什么使用break;直接return 结果会错误 why?
为什么要大于0; 第7 ,15行代码。why?