LeetCode刷题笔记 1160. 拼写单词 【统计】【哈希表】

暴力解法

class Solution {
public:
    int countCharacters(vector<string>& words, string chars) {
        int num=words.size();
        int res=0;
        for(int i=0;i<num;i++){
            string used=chars;
            bool flag1=true;  / 判断该单词能否完成拼写
            for(int j=0;j<words[i].size();j++){
                bool flag2=false; / 判断字母表中是否有目前的字母
                for(int k=0;k<chars.size();k++){                    
                    if(words[i][j]==used[k]){
                        used[k]='0';
                        flag2=true;
                        break;
                    }
                    if(flag2) break;
                }
                if(flag2) continue;
                else{
                    flag1=false;
                    break;
                }
            }
            if(flag1) res+=words[i].size();
        }
        return res;
    }
};

执行用时	内存消耗
72 ms	18 MB

统计法

统计字母出现的次数，数组技巧
更符合这道题的需求。

class Solution {
public:
    // 统计 26 个字母出现的次数
    vector<int> count(string& word) {
        vector<int> counter(26, 0);
        for (char c : word) {
            counter[c-'a']++;
        }
        return counter;
    }
    // 检查字母表的字母出现次数是否覆盖单词的字母出现次数
    bool contains(vector<int>& chars_count, vector<int>& word_count) {
        for (int i = 0; i < 26; i++) {
            if (chars_count[i] < word_count[i]) {
                return false;
            }
        }
        return true;
    }

    int countCharacters(vector<string>& words, string chars) {
        vector<int> chars_count = count(chars); // 统计字母表的字母出现次数
        int res = 0;
        for (string& word : words) {
            vector<int> word_count = count(word); // 统计单词的字母出现次数
            if (contains(chars_count, word_count)) {
                res += word.length();
            }
        }
        return res;
    }
};

执行用时	内存消耗
68 ms	20 MB

哈希表法

能应付更多情况，和方法二事实上是一个思路，但资源消耗有点夸张。

class Solution {
public:
    int countCharacters(vector<string>& words, string chars) {
        unordered_map<char, int> chars_cnt;
        for (char c : chars)
            ++chars_cnt[c];
        int ans = 0;
        for (string& word : words) {
            unordered_map<char, int> word_cnt;
            for (char c : word)
                ++word_cnt[c];
            bool is_ans = true;
            for (char c : word)
                if (chars_cnt[c] < word_cnt[c]) {
                    is_ans = false;
                    break;
                }
            if (is_ans)
                ans += word.size();
        }
        return ans;
    }
};

执行用时	内存消耗
384 ms	56 MB

另

map和unordered_map的差别和使用