当需要判断一个元素是否出现过的时候，就考虑哈希表
1. 哈希表的本质是空间换时间，通过数组，set，map将数据已经预处理
2. set的限制是只能存放单一key，不能记录更多的数据
3. 进而考虑map，map通过<key,value>的存储数据，允许我们更加灵活的存储哈希值和对应的数值
383. 赎金信
383. 赎金信
给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。
(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)
注意：
你可以假设两个字符串均只含有小写字母。
canConstruct("a", "b") -> false
canConstruct("aa", "ab") -> false
canConstruct("aa", "aab") -> true
class Solution {
public:
bool canConstruct(string ransomNote, string magazine) {
if(ransomNote.size()==0) return true;
if(magazine.size()==0) return false;
if(ransomNote.size()>magazine.size()) return false;
auto it=magazine.begin();
unordered_map<int,int> m_map;
while(it!=magazine.end()){
char tmp=*it;
m_map[tmp]++;
it++;
}
auto rit=ransomNote.begin();
while(rit!=ransomNote.end()){
char tmp=*rit;
if(m_map[tmp]!=0)
m_map[tmp]--;
else return false;
rit++;
}
return true;
}
};
575. 分糖果
575. 分糖果
给定一个偶数长度的数组，其中不同的数字代表着不同种类的糖果，每一个数字代表一个糖果。你需要把这些糖果平均分给一个弟弟和一个妹妹。返回妹妹可以获得的最大糖果的种类数。
示例 1:
输入: candies = [1,1,2,2,3,3]
输出: 3
解析: 一共有三种种类的糖果，每一种都有两个。
最优分配方案：妹妹获得[1,2,3],弟弟也获得[1,2,3]。这样使妹妹获得糖果的种类数最多。
示例 2 :
输入: candies = [1,1,2,3]
输出: 2
解析: 妹妹获得糖果[2,3],弟弟获得糖果[1,1]，妹妹有两种不同的糖果，弟弟只有一种。这样使得妹妹可以获得的糖果种类数最多。
注意:
数组的长度为[2, 10,000]，并且确定为偶数。
数组中数字的大小在范围[-100,000, 100,000]内。
class Solution1 {
//哈希表 两次遍历时间复杂度O（N）
public:
int distributeCandies(vector<int>& candies) {
int size=candies.size();
if(size==0) return 0;
auto it=candies.begin();
unordered_map<int,int> um;
while(it!=candies.end()){
um[*it]++;
it++;
}
auto mit=um.begin();
int sigle=0;
int multi=0;
while(mit!=um.end()){
if(mit->second>1)
multi++;
else
sigle++;
mit++;
}
if(sigle+multi>=size/2)
return size/2;
else
return sigle+multi;
}
};
class Solution {
//哈希表 两次遍历时间复杂度O（N）第二次遍历并不需要单个的和多个的具体数目
public:
int distributeCandies(vector<int>& candies) {
int size=candies.size();
if(size==0) return 0;
auto it=candies.begin();
unordered_map<int,int> um;
while(it!=candies.end()){
um[*it]++;
it++;
}
// auto mit=um.begin();
// int sigle=0;
// int multi=0;
// while(mit!=um.end()){
// if(mit->second>1)
// multi++;
// else
// sigle++;
// mit++;
//}
if(um.size()>=size/2)
return size/2;
else
return um.size();
}
};
class Solution3 {
//事实上两边遍历map就是初始化set的过程
public:
int distributeCandies(vector<int>& candies) {
int size=candies.size();
//if(size==0) return 0;
unordered_set<int> is(candies.begin(),candies.end());
return size/2>is.size()?is.size():size/2;
}
};
349. 两个数组的交集
349. 两个数组的交集
给定两个数组，编写一个函数来计算它们的交集。
示例 1：
输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]
示例 2：
输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]
说明：
输出结果中的每个元素一定是唯一的。
我们可以不考虑输出结果的顺序。
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
int len1=nums1.size();
int len2=nums2.size();
// vector<int> res;
// for(int i=0;i<nums1.size();i++){ }
// for(int i=0;i<len1;i++){
// for(int j=0;j<len2;j++){
// if(nums2[j]==nums1[i]){
// res.push_back(nums1[i]);
// break;
// }
// }
//}
unordered_set<int> nums1_set(nums1.begin(),nums1.end());
unordered_set<int> ans;
for(auto num:nums2){
if(nums1_set.count(num)==1)
ans.insert(num);
}
return vector<int>(ans.begin(),ans.end());
}
};
202. 快乐数
202. 快乐数
编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为 1，那么这个数就是快乐数。
如果 n 是快乐数就返回 True ；不是，则返回 False 。
示例：
输入：19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1
class Solution {
public:
bool isHappy(int n) {
int ans=n;
unordered_set<int> us;
us.insert(n);
while(ans!=1){
string s_ans=to_string(ans);
int sum=0;
for(auto c:s_ans){
int tmp=c-48;
sum+=tmp*tmp;
}
if(us.count(sum)<1)
us.insert(sum);
else return false;
ans=sum;
}
return true;
}
};
1. 两数之和
1. 两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
通过次数1,350,215提交次数2,736,274
class Solution1 {
//暴力法
public:
vector<int> twoSum(vector<int>& nums, int target) {
vector<int> a;
for(int i=0;i<nums.size()-1;i++){
for(int j=i+1;j<nums.size();j++){
if(nums[i]+nums[j]==target){
a.push_back(i);
a.push_back(j);
}
}
}
return a;
}
};
class Solution {
//哈希表
public:
vector<int> twoSum(vector<int>& nums, int target) {
unordered_map<int,int> um;
for(int i=0;i<nums.size();i++){
um[nums[i]]=i;
}
for(int i=0;i<nums.size();i++){
if(um.count(target-nums[i])>0&&um[target-nums[i]]!=i)
return {
i,um[target-nums[i]]};
}
return {
-1,-1};
}
};
274. H 指数
274. H 指数
给定一位研究者论文被引用次数的数组（被引用次数是非负整数）。编写一个方法，计算出研究者的 h 指数。
h 指数的定义：h 代表“高引用次数”（high citations），一名科研人员的 h 指数是指他（她）的 （N 篇论文中）总共有 h 篇论文分别被引用了至少 h 次。（其余的 N - h 篇论文每篇被引用次数 不超过 h 次。）
例如：某人的 h 指数是 20，这表示他已发表的论文中，每篇被引用了至少 20 次的论文总共有 20 篇。
示例：
输入：citations = [3,0,6,1,5]
输出：3
解释：给定数组表示研究者总共有 5 篇论文，每篇论文相应的被引用了 3, 0, 6, 1, 5 次。
由于研究者有 3 篇论文每篇 至少 被引用了 3 次，其余两篇论文每篇被引用 不多于 3 次，所以她的 h 指数是 3。
提示：如果 h 有多种可能的值，h 指数是其中最大的那个。
通过次数16,308提交次数41,963
class Solution {
public:
int hIndex(vector<int>& citations) {
sort(citations.begin(),citations.end());
for(int i=0;i<citations.size();i++){
int h=citations.size()-i;
if(h<=citations[i])
return h;
}
return 0;
}
};
更多哈希表练习
205. 同构字符串
599. 两个列表的最小索引总和
242. 有效的字母异位词
454.四数之和
219. 存在重复元素 II
217. 存在重复元素
220. 存在重复元素 III