feat: 回溯模板 & $1255

Author: lucifer

README.md

@@ -163,14 +163,15 @@ leetcode 题解，记录自己的 leetcode 解题之路。
 - [基础算法](./thinkings/basic-algorithm.md)
 - [二叉树的遍历](./thinkings/binary-tree-traversal.md)
 - [动态规划](./thinkings/dynamic-programming.md)
+- [回溯](./thinkings/backtrack.md)
 - [哈夫曼编码和游程编码](./thinkings/run-length-encode-and-huffman-encode.md)
 - [布隆过滤器](./thinkings/bloom-filter.md)🖊
 - [字符串问题](./thinkings/string-problems.md)
-- [前缀树专题](./thinkings/trie.md)
+- [前缀树](./thinkings/trie.md)
 - [《日程安排》专题](https://lucifer.ren/blog/2020/02/03/leetcode-%E6%88%91%E7%9A%84%E6%97%A5%E7%A8%8B%E5%AE%89%E6%8E%92%E8%A1%A8%E7%B3%BB%E5%88%97/)
 - [《构造二叉树》专题](https://lucifer.ren/blog/2020/02/08/%E6%9E%84%E9%80%A0%E4%BA%8C%E5%8F%89%E6%A0%91%E4%B8%93%E9%A2%98/)
 - [《贪婪策略》专题](./thinkings/greedy.md)🖊
-- [《深度优先遍历》专题](./thinkings/DFS.md)
+- [深度优先遍历](./thinkings/DFS.md)
 - [滑动窗口（思路 + 模板）](./thinkings/slide-window.md)
 - [位运算](./thinkings/bit.md)
 - [设计题](./thinkings/design.md)

SUMMARY.md

@@ -10,9 +10,10 @@
     * [哈夫曼编码和游程编码](thinkings/run-length-encode-and-huffman-encode.md)
     * [布隆过滤器](thinkings/bloom-filter.md)
     * [字符串问题](thinkings/string-problems.md)
-    * [前缀树专题](thinkings/trie.md)
-    * [《贪婪策略》专题](thinkings/greedy.md)
-    * [《深度优先遍历》专题](thinkings/DFS.md)
+    * [前缀树](thinkings/trie.md)
+    * [贪婪策略](thinkings/greedy.md)
+    * [深度优先遍历](thinkings/DFS.md)
+    * [回溯](thinkings/backtrack.md)
     * [滑动窗口（思路 + 模板）](thinkings/slide-window.md)
     * [位运算](thinkings/bit.md)
     * [设计题](thinkings/design.md)
@@ -223,6 +224,7 @@
     * [0895. 最大频率栈](problems/895.maximum-frequency-stack.md)
     * [1032. 字符流](problems/1032.stream-of-characters.md)
     * [1168. 水资源分配优化](problems/1168.optimize-water-distribution-in-a-village.md)
+    * [1255. 得分最高的单词集合](../problems/1255.maximum-score-words-formed-by-letters.md)
     * [1449. 数位成本和为目标值的最大数字](problems/1449.form-largest-integer-with-digits-that-add-up-to-target.md)
 
 

collections/hard.md

@@ -25,12 +25,12 @@
 以下是我列举的经典题目：
 
 - [0004. 寻找两个正序数组的中位数](../problems/4.median-of-two-sorted-arrays.md)
-- [0023. 合并K个升序链表](../problems/23.merge-k-sorted-lists.md)
+- [0023. 合并 K 个升序链表](../problems/23.merge-k-sorted-lists.md)
 - [0025. K 个一组翻转链表](../problems/25.reverse-nodes-in-k-groups.md)
 - [0030. 串联所有单词的子串](../problems/30.substring-with-concatenation-of-all-words.md)
 - [0032. 最长有效括号](../problems/32.longest-valid-parentheses.md)
 - [0042. 接雨水](../problems/42.trapping-rain-water.md)
-- [0052. N皇后 II](../problems/52.N-Queens-II.md)
+- [0052. N 皇后 II](../problems/52.N-Queens-II.md)
 - [0084. 柱状图中最大的矩形](../problems/84.largest-rectangle-in-histogram.md)
 - [0085. 最大矩形](../problems/85.maximal-rectangle.md)
 - [0124. 二叉树中的最大路径和](../problems/124.binary-tree-maximum-path-sum.md)
@@ -42,12 +42,13 @@
 - [0301. 删除无效的括号](../problems/301.remove-invalid-parentheses.md)
 - [0312. 戳气球](../problems/312.burst-balloons.md)
 - [0335. 路径交叉](../problems/335.self-crossing.md)
-- [0460. LFU缓存](../problems/460.lfu-cache.md)
+- [0460. LFU 缓存](../problems/460.lfu-cache.md)
 - [0472. 连接词](../problems/472.concatenated-words.md)
 - [0488. 祖玛游戏](../problems/488.zuma-game.md)
 - [0493. 翻转对](../problems/493.reverse-pairs.md)
 - [0887. 鸡蛋掉落](../problems/887.super-egg-drop.md)
 - [0895. 最大频率栈](../problems/895.maximum-frequency-stack.md)
 - [1032. 字符流](../problems/1032.stream-of-characters.md)
 - [1168. 水资源分配优化](../problems/1168.optimize-water-distribution-in-a-village.md)
+- [1255. 得分最高的单词集合](../problems/1255.maximum-score-words-formed-by-letters.md)
 - [1449. 数位成本和为目标值的最大数字](../problems/1449.form-largest-integer-with-digits-that-add-up-to-target.md)

problems/113.path-sum-ii.md

@@ -1,7 +1,9 @@
 ## 题目地址(113. 路径总和 II)
+
 https://leetcode-cn.com/problems/path-sum-ii/
 
 ## 题目描述
+
 ```
 给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。
 
@@ -41,9 +43,7 @@ https://leetcode-cn.com/problems/path-sum-ii/
 
 这道题目是求集合，并不是`求值`，而是枚举所有可能，因此动态规划不是特别切合，因此我们需要考虑别的方法。
 
-这种题目其实有一个通用的解法，就是回溯法。
-网上也有大神给出了这种回溯法解题的
-[通用写法](https://leetcode.com/problems/combination-sum/discuss/16502/A-general-approach-to-backtracking-questions-in-Java-(Subsets-Permutations-Combination-Sum-Palindrome-Partitioning))，这里的所有的解法使用通用方法解答。
+这种题目其实有一个通用的解法，就是回溯法。网上也有大神给出了这种回溯法解题的[通用写法](<https://leetcode.com/problems/combination-sum/discuss/16502/A-general-approach-to-backtracking-questions-in-Java-(Subsets-Permutations-Combination-Sum-Palindrome-Partitioning)>)，这里的所有的解法使用通用方法解答。
 除了这道题目还有很多其他题目可以用这种通用解法，具体的题目见后方相关题目部分。
 
 我们先来看下通用解法的解题思路，我画了一张图：
@@ -59,10 +59,9 @@ https://leetcode-cn.com/problems/path-sum-ii/
 - 回溯法
 - backtrack 解题公式
 
-
 ## 代码
 
-* 语言支持：JS，C++，Python3
+- 语言支持：JS，C++，Python3
 
 JavaScript Code：
 
@@ -95,14 +94,16 @@ function backtrack(root, sum, res, tempList) {
  * @param {number} sum
  * @return {number[][]}
  */
-var pathSum = function(root, sum) {
+var pathSum = function (root, sum) {
   if (root === null) return [];
   const res = [];
   backtrack(root, sum, res, []);
   return res;
 };
 ```
+
 C++ Code:
+
 ```C++
 /**
  * Definition for a binary tree node.
@@ -131,10 +132,11 @@ private:
             backtrack(root->left, sum - root->val, ret, tempList);
             backtrack(root->right, sum - root->val, ret, tempList);
         }
-        tempList.pop_back();        
+        tempList.pop_back();
     }
 };
 ```
+
 ```python
 # Definition for a binary tree node.
 # class TreeNode:
@@ -147,9 +149,9 @@ class Solution:
     def pathSum(self, root: TreeNode, sum: int) -> List[List[int]]:
         if not root:
             return []
-        
+
         result = []
-        
+
         def trace_node(pre_list, left_sum, node):
             new_list = pre_list.copy()
             new_list.append(node.val)
@@ -162,10 +164,11 @@ class Solution:
                     trace_node(new_list, left_sum-node.val, node.left)
                 if node.right:
                     trace_node(new_list, left_sum-node.val, node.right)
-        
+
         trace_node([], sum, root)
         return result
 ```
+
 ## 相关题目
 
 - [39.combination-sum](./39.combination-sum.md)
@@ -175,5 +178,3 @@ class Solution:
 - [78.subsets](./78.subsets.md)
 - [90.subsets-ii](./90.subsets-ii.md)
 - [131.palindrome-partitioning](./131.palindrome-partitioning.md)
-
-

problems/1255.maximum-score-words-formed-by-letters.md

@@ -0,0 +1,135 @@
+## 题目地址（1255. 得分最高的单词集合）
+
+https://leetcode-cn.com/problems/maximum-score-words-formed-by-letters/
+
+## 题目描述
+
+```
+你将会得到一份单词表 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 组合，然后判断是否可以满足单词拼写的游戏规则，最后找出所有满足条件的最大分数即可。因此这道题可以用到 [78. 子集](../problems/78.subsets.md) 的代码。
+
+由排列组合原理可知， 一个大小为 N 的集合的组合数是 2^N，因此这种解法的时间复杂度也大致是这个量级。
+
+这道题比[78. 子集](../problems/78.subsets.md) 稍微复杂一点，不管是题目的数据输入还是限制条件都更复杂。
+
+实际上， 这些限制条件影响的只是部分细节，我们仍然套用回溯的模板即可， 关于回溯模板可参考：[回溯专题](../thinkings/backtrack.md)。
+
+核心伪代码如下：
+
+```py
+class Solution:
+    def maxScoreWords(self, words, letters, score):
+        ans = 0
+
+        def dfs(start, 当前的分数, counter):
+            if start > len(words): return
+            ans = max(ans, cur)
+            for j in 循环start之后的单词:
+                if 如果当前单词加进去还满足游戏规则:
+                    dfs(j + 1, 新的分数, 新的counter)
+
+        dfs(0, 0, collections.Counter(letters))
+        return ans
+```
+
+> 由于每次都新生成一个 counter，因此状态不需要回溯。
+
+其中 collections.Counter(letters) 的功能是计数，比如['a', 'a', 'c', 'b']，会被处理为 { a: 2, b: 1, c: 1}。其功能是用于判断**当前单词加进去是否还满足游戏规则**。具体可以参考下方的代码区。
+
+## 关键点
+
+- 回溯模板
+- 计数
+
+## 代码
+
+代码支持 Python3:
+
+Python3 Code:
+
+```python
+class Solution:
+    def maxScoreWords(self, words, letters, score):
+        self.ans = 0
+        words_score = [sum(score[ord(c)-ord('a')] for c in word) for word in words]
+        words_counter = [collections.Counter(word) for word in words]
+
+        def backtrack(start, cur, counter):
+            if start > len(words):
+                return
+            self.ans = max(self.ans, cur)
+            for j, w_counter in enumerate(words_counter[start:], start):
+                if all(n <= counter.get(c,0) for c,n in w_counter.items()):
+                    backtrack(j+1, cur+words_score[j], counter-w_counter)
+
+        backtrack(0, 0, collections.Counter(letters))
+        return self.ans
+```
+
+**复杂度分析**
+
+- 时间复杂度：$O(2^N)$，其中 N 为 words 的个数。
+- 空间复杂度：$O(total)$，其中 total 为 words 中的字符总数。
+
+大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。
+大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。
+![](https://tva1.sinaimg.cn/large/007S8ZIlly1gfcuzagjalj30p00dwabs.jpg)