代码随想录-哈希表|ACM模式
目录
前言：
（1）基本概念
（2）常见的三种哈希结构
242.有效字母的异位词
题目描述：
输入输出描述：
思路和想法:
349. 两个数组的交集
题目描述：
输入输出描述：
思路和想法：
202. 快乐数
题目描述：
输入输出描述：
思路和想法：
1. 两数之和
题目描述：
输入输出描述：
思路和想法：
454. 四数相加 II
题目描述：
输入输出描述：
思路和想法：
383. 赎金信
题目描述：
输入输出描述：
思路和想法
前言：
（1）基本概念
就是用哈希函数构建索引和内容之间的映射。就相当于一个内容就会有相对应的哈希函数值（即索引下标），直接找下标，就能查询是否有相应的内容。
在这个过程中，可能会遇到两个同时映射到一个，这个就是哈希碰撞的现象，应对这个方法常见的有两种，其中一个是拉链法（即采用链表的方式），另一个就是线性探测法。
①拉链法需要选择适当的哈希表的大小----不会因为数组空值而浪费大量内存，另一个不会链表太长而在查找上浪费太多时间。
②线性探测法，一定要保证tablesize大于datasize。依靠哈希表空位来解决碰撞问题。
（2）常见的三种哈希结构
数组、set（集合）以及map（映射）
242.有效字母的异位词
题目描述：
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
输入输出描述：
示例 1:
输入: s = "anagram", t = "nagaram" 输出: true
示例 2:
输入: s = "rat", t = "car" 输出: false
提示:
- 1 <= s.length, t.length <= 5 * 104
- s 和 t 仅包含小写字母
思路和想法:
这个问题可以分为三个步骤来解决。
- 步骤一：构建Hash table-数组，之后遍历第一个字符串将里面的元素一一对应到哈希表上记录频次。
- 步骤二：再遍历第二个字符串，将相应位置--。
- 步骤三：最终只需判断哈希表内元素是否都为零，就可以判断这两个字符串是否互为有效字母异位词。
#include
using namespace std;
bool isAnagram(string s, string t) {
//将a-z，26个字母到0-25
//哈希表
unordered_map m;
for(int i = 0; i < s.size(); i++ ){
m[s[i]-'a']++;
}
for(int i = 0; i < t.size(); i++){
m[t[i]-'a']--;
}
for(int i = 0; i < 26;i++){
if(m[i] != 0) return false;
}
return true;
}
int main() {
string s,t;
getline(cin,s);
getline(cin,t);
bool result;
result = isAnagram(s,t);
if(result == 1){
cout << "true";
}else{
cout << "false";
}
return 0;
}
/************
示例1:
anagram
nagaram
示例2:
rat
car
*************/ 349. 两个数组的交集
题目描述：
给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。
输入输出描述：
示例 1：
输入：nums1 = [1,2,2,1], nums2 = [2,2] 输出：[2]
示例 2：
输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4] 输出：[9,4] 解释：[4,9] 也是可通过的
提示：
- 1 <= nums1.length, nums2.length <= 1000
- 0 <= nums1[i], nums2[i] <= 1000
思路和想法：
可以清晰的知道我们要判断元素在集合中是否出现过。这里数值较大，适合采用set的方式，并且非重复，考虑时间复杂度和空间复杂度，采用unordered_set。
将第一个数组进行处理转换成set，再用numbers2遍历查询是否出现过，放在result集合里。
#include
using namespace std;
vector intersection(vector& nums1, vector& nums2) {
unordered_set result;
unordered_set nums_set(nums1.begin(), nums1.end()); //将数组1转换成哈希表
for(int i = 0; i < nums2.size(); i++){
if(nums_set.find(nums2[i]) != nums_set.end()){
result.insert(nums2[i]); //set插入元素操作
}
}
return vector (result.begin(), result.end());
}
int main() {
vector nums1,nums2;
int num;
//nums1
while(cin >> num) {
nums1.push_back(num);
// 读到换行符，终止循环
if(getchar() == '\n') {
break;
}
}
//nums2
while(cin >> num) {
nums2.push_back(num);
// 读到换行符，终止循环
if(getchar() == '\n') {
break;
}
}
vector result;
result = intersection(nums1,nums2);
for(int i = 0; i < result.size(); i++) {
cout << result[i] << " ";
}
cout << endl;
return 0;
}
/*************
示例1:
1 2 2 1
2 2
示例2:
4 9 5
9 4 9 8 4
************/ 202. 快乐数
题目描述：
编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」 定义为：
- 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
- 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
- 如果这个过程 结果为 1，那么这个数就是快乐数。
如果 n 是 快乐数 就返回 true ；不是，则返回 false 。
输入输出描述：
示例 1：
输入：n = 19 输出：true 解释： 12 + 92 = 82 82 + 22 = 68 62 + 82 = 100 12 + 02 + 02 = 1
示例 2：
输入：n = 2 输出：false
提示：
- 1 <= n <= 2^31 - 1
思路和想法：
这里比较重要的地方，在于判断什么时候出现无限循环，即判断平方和数值重复出现。这里就是判断元素有无重复出现，就可以set来解决了。解决这道题目具体的步骤如下：
步骤一：计算数n的各个位置的平方和
步骤二：判断是否出现了1，并进行循环，如果在这个过程中，在set集合中找到元素，则证明出现循环，return false。
#include
using namespace std;
int Sum(int n){
int sum = 0;
while(n){
sum += (n % 10) * (n % 10);
n /= 10;
}
return sum;
}
bool isHappy(int n) {
unordered_set set;
while(1){
int sum1 = Sum(n);
if(sum1 == 1){
return true;
}
if (set.find(sum1) != set.end()) {
return false;
} else {
set.insert(sum1);
}
n = sum1;
}
}
int main() {
int number;
cin >> number;
bool result;
result = isHappy(number);
if(result == 1){
cout << "true" < 1. 两数之和
题目描述：
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
输入输出描述：
示例 1：
输入：nums = [2,7,11,15], target = 9 输出：[0,1] 解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：
输入：nums = [3,2,4], target = 6 输出：[1,2]
示例 3：
输入：nums = [3,3], target = 6 输出：[0,1]
提示：
- 2 <= nums.length <= 104
- -109 <= nums[i] <= 109
- -109 <= target <= 109
- 只会存在一个有效答案
思路和想法：
在判断元素有无的同时，也要存储下标，所以这里我们采用unorderded_map。其中map结构--key（元素），value（下标）。
#include
using namespace std;
vector twoSum(vector& nums, int target) {
unordered_map map;
for(int i = 0; i < nums.size(); i++) {
// 遍历当前元素，并在map中寻找是否有匹配的key
auto iterm = map.find(target - nums[i]);
if(iterm != map.end()) {
return {iterm->second, i};
}
// 如果没找到匹配对，就把访问过的元素和下标加入到map中
map.insert(pair(nums[i], i));
}
return {};
}
int main() {
vector nums;
int num;
while(cin >> num){
nums.push_back(num);
if(getchar() == '\n'){
break;
}
}
int target;
cin >> target;
vector result;
result = twoSum(nums,target);
for (int i = 0; i < result.size(); ++i) {
cout << result[i] << " ";
}
cout << endl;
return 0;
}
/*************
示例1:
2 7 11 15
9
示例2:
3 2 4
6
示例3：
3 3
6
************/ 454. 四数相加 II
题目描述：
给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：
- 0 <= i, j, k, l < n
- nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0
输入输出描述：
示例 1：
输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2] 输出：2
解释： 两个元组如下： 1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0 2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0
示例 2：
输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0] 输出：1
提示：
- n == nums1.length
- n == nums2.length
- n == nums3.length
- n == nums4.length
- 1 <= n <= 200
- -2^28 <= nums1[i], nums2[i], nums3[i], nums4[i] <= 2^28
思路和想法：
将四个数组简化成两个数组，并将其中一个放入map中，key放两两数组加和值，value放数组下标。
步骤一：先构建一个哈希表（nums1），存储key以及value，key对应数组之和，value记录次数。
步骤二：nums3 + nums4，进行map查询，寻找里面是否有其相反数的映射。
#include
using namespace std;
int fourSumCount(vector& nums1, vector& nums2, vector& nums3, vector& nums4) {
std::unordered_map h1;
//步骤一，构建哈希表，存储key以及value
int size = nums1.size();
int sum = 0; //key---数组两两加和值
int Ycount = 0; //记录多少个元组满足
for(int i = 0; i < size; i++){
for(int j = 0; j < size; j++){
sum = nums1[i] + nums2[j];
h1[sum]++;
}
}
//步骤二，map查询，记录次数
for(int i = 0; i < size; i++){
for(int j = 0; j < size; j++){
sum = nums3[i] + nums4[j];
auto item = h1.find(-sum);
if(item != h1.end()){
Ycount += h1[-sum];
}
}
}
return Ycount;
}
int main() {
int n;
cin >> n;
vector n1(n),n2(n),n3(n),n4(n);
for (int i = 0; i < n; ++i) {
cin >> n1[i];
}
for (int i = 0; i < n; ++i) {
cin >> n2[i];
}
for (int i = 0; i < n; ++i) {
cin >> n3[i];
}
for (int i = 0; i < n; ++i) {
cin >> n4[i];
}
int result;
result = fourSumCount(n1,n2,n3,n4);
cout << result << endl;
return 0;
}
/*************
示例1:
2
1 2
-2 -1
-1 2
0 2
示例2:
1
0
0
0
0
************/ 383. 赎金信
题目描述：
给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。
如果可以，返回 true ；否则返回 false 。
magazine 中的每个字符只能在 ransomNote 中使用一次。
输入输出描述：
示例 1：
输入：ransomNote = "a", magazine = "b" 输出：false
示例 2：
输入：ransomNote = "aa", magazine = "ab" 输出：false
示例 3：
输入：ransomNote = "aa", magazine = "aab" 输出：true
提示：
- 1 <= ransomNote.length, magazine.length <= 105
- ransomNote 和 magazine 由小写英文字母组成
思路和想法：
这里分为三个步骤。
- 步骤一：用哈希数组记录magzine字母出现次数
- 步骤二：遍历ransomNote，消耗magzine
- 步骤三：判断magzine是否透支（有负数），是则返回false
#include
using namespace std;
bool canConstruct(string ransomNote, string magazine) {
//因为magzine只由小写字母组成，26,采用数组哈希解决最好，不占空间的同时，查询时间也很短
int h1[26] = {0};
//步骤一，进行遍历,记录字母出现次数
for(int i = 0; i < magazine.size(); i++){
h1[magazine[i]-'a']++;
}
//步骤二：再对ransomNote进行遍历，对应--
for(int i = 0; i < ransomNote.size(); i++ ){
h1[ransomNote[i]-'a']--;
}
//步骤三：对数组遍历，看其是否存在负数，存在return false
for(int i = 0; i < 26;i++){
if(h1[i] < 0) return false;
}
return true;
}
int main() {
string str1,str2;
getline(cin,str1);
getline(cin,str2);
bool result;
result = canConstruct(str1,str2);
if(result == 1){
cout << "true" << endl;
}else{
cout << "false" << endl;
}
return 0;
}
/*************
示例1:
a
b
示例2:
aa
ab
示例3：
aa
aab
************/