leetcode383. 赎金信
在哈希法中有一些场景就是为数组量身定做的。
1 题目
题源链接
给你两个字符串: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 由小写英文字母组成
2 思路
这道题目和242.有效的字母异位词 很像,242.有效的字母异位词相当于求 字符串a 和 字符串b 是否可以相互组成 ,而这道题目是求 字符串a能否组成字符串b,而不用管字符串b 能不能组成字符串a。
本题注意两点:
- magazine中字母不可重复使用;
- 题设中说明了两个字符串中均只含有小写字母。
暴力解法自然是两层for循环,这里不作说明;
接下来自然而然就是哈希解法:
采用空间换取时间的哈希策略, 用一个长度为26的数组还记录magazine里字母出现的次数。
然后再用ransomNote去验证这个数组是否包含了ransomNote所需要的所有字母。
依然是数组在哈希法中的应用。
- 为什么不用map呢?
在本题的情况下,使用map的空间消耗要比数组大一些的,因为map要维护红黑树或者哈希表,而且还要做哈希函数,是费时的!数据量大的话就能体现出来差别了。 所以数组更加简单直接有效!
3 代码
3.1 C++版本
class Solution {
public:
bool canConstruct(string ransomNote, string magazine) {
int record[26] = {0}; //记录magazine中每个字母出现的次数
if (ransomNote.size() > magazine.size())
return false;
for (int i = 0; i < magazine.size(); i++) {
record[magazine[i]-'a'] ++; //题目描述中两个字符串中均为小写字母
}
for (int j = 0; j < ransomNote.size(); j++) {
record[ransomNote[j]-'a'] --;
if (record[ransomNote[j]-'a'] < 0)
return false; //说明ransomNote中出现的字符magazine中没有
}
return true;
}
};
3.2 C版本
bool canConstruct(char * ransomNote, char * magazine){
int record[26] = {0};
if(strlen(ransomNote) > strlen(magazine)){
return false;
}
for(int i = 0; i < strlen(magazine); i++){
record[magazine[i] - 'a'] += 1;
}
for(int i = 0; i < strlen(ransomNote); i++){
record[ransomNote[i] - 'a'] -= 1;
if(record[ransomNote[i] - 'a'] < 0)
return false;
}
return true;
}
3.3 Java版本
class Solution {
public boolean canConstruct(String ransomNote, String magazine) {
int[] record = new int[26];
if (ransomNote.length() > magazine.length())
return false;
for (char c : magazine.toCharArray())
record[c - 'a'] += 1;
for (char c : ransomNote.toCharArray()) {
record[c - 'a'] -= 1;
if (record[c - 'a'] < 0)
return false;
}
return true;
}
}
3.4 Python版本
class Solution:
def canConstruct(self, ransomNote: str, magazine: str) -> bool:
record = [0] * 26
if len(ransomNote) > len(magazine):
return False
for i in magazine:
record[ord(i) - ord('a')] += 1
for j in ransomNote:
if record[ord(j) - ord('a')] == 0:
return False
else:
record[ord(j) - ord('a')] -= 1
return True
3.5 JavaScript版本
/**
* @param {string} ransomNote
* @param {string} magazine
* @return {boolean}
*/
var canConstruct = function(ransomNote, magazine) {
const strArr = new Array(26).fill(0),
base = "a".charCodeAt();
for(const s of magazine) { // 记录 magazine里各个字符出现次数
strArr[s.charCodeAt() - base]++;
}
for(const s of ransomNote) { // 对应的字符个数做--操作
const index = s.charCodeAt() - base;
if(!strArr[index]) return false; // 如果没记录过直接返回false
strArr[index]--;
}
return true;
};
4 总结
在哈希法中有一些场景就是为数组量身定做的。
这道题目是求 字符串a能否组成字符串b,而不用管字符串b 能不能组成字符串a。因为题目所只有小写字母,那可以采用空间换取时间的哈希策略,
- 用一个长度为26的数组还记录magazine里字母出现的次数。
- 然后再用ransomNote去验证这个数组是否包含了ransomNote所需要的所有字母。
依然是数组在哈希法中的应用。
使用map的空间消耗要比数组大一些的,因为map要维护红黑树或者哈希表,而且还要做哈希函数,是费时的!数据量大的话就能体现出来差别了。 所以数组更加简单直接有效!
By – Suki 2023/2/1