[LeetCode] 383. 赎金信

1. 问题描述

383. 赎金信 - 力扣（LeetCode）

给你两个字符串：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. 实现思路

2.1 自己的思路

~~（一定要写出来啊喂_）~

先搞清楚哪个是可能”更大“的字符串：magazine

那么想出来的第一个思路是，哈希法，用字典<char, int>代表字符和对应出现的次数，先遍历magazine对其出现次数++，然后遍历ransomNote对其—，那么键值对中，值如果出现了负数，则答案为false，否则为true

public class Solution
{
    public bool CanConstruct(string ransomNote, string magazine)
    {
        var dict = new Dictionary<char, int>();
        foreach (var c in magazine)
        {
            if (dict.ContainsKey(c))
                dict[c]++;
            else
                dict.Add(c, 1);
        }

        foreach (var c in ransomNote)
        {
            if (dict.ContainsKey(c))
                dict[c]--;
            else
                return false;
        }

        foreach (var i in dict.Values)
            if (i < 0) return false;

        return true;
    }
}

那么有没有优化空间呢？之前好像遇到过类似的[LeetCode] 242.有效的字母异位词 - 绘星tsuki - 博客园

重新阅读题目发现，两个字符串只由小写字母组成，那就可以用数组代替字典了

public class Solution
{
    public bool CanConstruct(string ransomNote, string magazine)
    {
        var arr = new int[26];
        foreach (var c in magazine)
            arr[c - 'a']++;
        foreach (var c in ransomNote)
        {
            arr[c - 'a']--;
            if (arr[c - 'a'] < 0) return false;
        }
        return true;
    }
}

2.2 题解思路

383. 赎金信 | 哈希法 | 数组

需要注意的是两点

• magazine中的字母不能重复使用
• 两个字符串只有小写字母

暴力O(n^2）的解法就不提及了，此题依然是数组在哈希法中的应用

一些同学可能想，用数组干啥，都用map完事了，其实在本题的情况下，使用map的空间消耗要比数组大一些的，因为map要维护红黑树或者哈希表，而且还要做哈希函数，是费时的！数据量大的话就能体现出来差别了。 所以数组更加简单直接有效！

C++：

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;
    }
};

• 时间复杂度: O(m+n)，其中m表示ransomNote的长度，n表示magazine的长度
• 空间复杂度: O(1)

C#：

public bool CanConstruct(string ransomNote, string magazine) {
        if(ransomNote.Length > magazine.Length) return false;
        int[] letters = new int[26]; 
        foreach(char c in magazine){
            letters[c-'a']++;
        }
        foreach(char c in ransomNote){
            letters[c-'a']--;
            if(letters[c-'a']<0){
                return false;
            }
        }
        return true;
    }

可以发现首行多了一个长度的比较，其他的逻辑就类似了

2.3 优化（或者敲一遍题解？）

可能是第一次实现最优解？好耶

---

3. 补充知识と杂谈，总结

• 数组在哈希法中的应用