Leetcode.1255 得分最高的单词集合

题目链接

Leetcode.1255 得分最高的单词集合 Rating ：1882

题目描述

你将会得到一份单词表 words，一个字母表 letters（可能会有重复字母），以及每个字母对应的得分情况表 score。

请你帮忙计算玩家在单词拼写游戏中所能获得的「最高得分」：能够由 letters里的字母拼写出的 任意 属于 words单词子集中，分数最高的单词集合的得分。

单词拼写游戏的规则概述如下：

• 玩家需要用字母表 letters里的字母来拼写单词表 words中的单词。
• 可以只使用字母表 letters中的部分字母，但是每个字母最多被使用一次。
• 单词表 words中每个单词只能计分（使用）一次。
• 根据字母得分情况表score，字母 'a', 'b', 'c', ... , 'z'对应的得分分别为 score[0], score[1], ..., score[25]。
• 本场游戏的「得分」是指：玩家所拼写出的单词集合里包含的所有字母的得分之和。

示例 1：

输入：words = [“dog”,“cat”,“dad”,“good”], letters = [“a”,“a”,“c”,“d”,“d”,“d”,“g”,“o”,“o”], score = [1,0,9,5,0,0,3,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0]
输出：23
解释：
字母得分为 a=1, c=9, d=5, g=3, o=2
使用给定的字母表 letters，我们可以拼写单词 “dad” (5+1+5)和 “good” (3+2+2+5)，得分为 23 。
而单词 “dad” 和 “dog” 只能得到 21 分。

示例 2：

输入：words = [“xxxz”,“ax”,“bx”,“cx”], letters = [“z”,“a”,“b”,“c”,“x”,“x”,“x”], score = [4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,10]
输出：27
解释：
字母得分为 a=4, b=4, c=4, x=5, z=10
使用给定的字母表 letters，我们可以组成单词 “ax” (4+5)， “bx” (4+5) 和 “cx” (4+5) ，总得分为 27 。
单词 “xxxz” 的得分仅为 25 。

示例 3：

输入：words = [“leetcode”], letters = [“l”,“e”,“t”,“c”,“o”,“d”], score = [0,0,1,1,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0]
输出：0
解释：
字母 “e” 在字母表 letters 中只出现了一次，所以无法组成单词表 words 中的单词。

提示：

• $1<=words.length<=14$
• $1<=words[i].length<=15$
• $1<=letters.length<=100$
• $letters[i].length==1$
• $score.length==26$
• $0<=score[i]<=10$
• words[i]和 letters[i]只包含小写的英文字母。

分析：

我们注意到 words.size()最大只有 14，数据量非常小（一般这种数据量非常小的大概率是考察 回溯 或者是 状态压缩），我们就可以使用 回溯 ，求最大得分。

对于每一个 word[i]，我们都讨论，选 还是 不选

我们定义 $dfs(u,sum)$，代表目前正要处理单词word[u]，此时的得分是 sum。

• 不选 words[u]，那就直接跳过words[u]，即 $dfs(u+1,sum)$
• 选 words[u]，在剩余字母还够用的情况下，此时words[u]的得分为 k，即 $dfs(u+1,sum+k)$

注意：

• 当 u == n时，更新最大得分 ans，返回上一层。
• 当选了 words[u]之后，需要恢复现场（即回溯到本层的时候，和递归下去之前的状态是一样的）

时间复杂度 : $O(m+len\ast 2^n)$，其中 m是 letters,size()，len是words[u].size()

C++代码：

class Solution {
public:
    int maxScoreWords(vector<string>& words, vector<char>& letters, vector<int>& score) {
        int n = words.size();
        int cnt[26] = {};
        for(auto c:letters) cnt[c-'a']++;

        int ans = 0;

        function<void(int,int)> dfs = [&](int u,int x){
            if(u >= n){
                ans = max(ans,x);
                return;
            }

            //不选第 u 个单词
            dfs(u+1,x);

            //选第 u 个单词
            bool ok = true;
            for(auto c:words[u]){
                //剩余字母不够了
                if(cnt[c-'a']-- == 0) ok = false;
                x += score[c - 'a'];
            }

            //剩余字母够选单词 word[u]
            if(ok) dfs(u+1,x);

            //恢复现场
            for(auto c:words[u]) cnt[c-'a']++;
        };

        dfs(0,0);

        return ans;
    }
};

Python3代码：

class Solution:
    def maxScoreWords(self, words: List[str], letters: List[str], score: List[int]) -> int:
        ans , n = 0 , len(words)
        cnt = Counter(letters)
        score = dict(zip(ascii_lowercase,score))

        def dfs(u:int,sum:int) -> None:
            if u >= n:
                nonlocal ans
                ans = max(ans,sum)
                return


            #不选第 u 个单词
            dfs(u+1,sum)

            #选第 u 个单词

            for i,c in enumerate(words[u]) :

                #剩余字母不够了
                if cnt[c] == 0 :
                  #撤销之前用过的字母 
                  for ch in words[u][:i]:
                      cnt[ch] += 1
                  return
                cnt[c] -= 1
                sum += score[c]

            dfs(u+1,sum)

            #恢复现场
            for c in words[u]:
                cnt[c] += 1

        dfs(0,0)
        return ans