feat: $17 笛卡尔积优化

Author: lucifer

problems/17.Letter-Combinations-of-a-Phone-Number.md

@@ -25,6 +25,7 @@ https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number
 ## 前置知识
 
 - 回溯
+- 笛卡尔积
 
 ## 公司
 
@@ -33,7 +34,9 @@ https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number
 - 字节
 - 腾讯
 
-## 思路
+## 回溯
+
+### 思路
 
 由于要求所有的可能性，因此考虑使用回溯法进行求解。回溯是一种通过穷举所有可能情况来找到所有解的算法。如果一个候选解最后被发现并不是可行解，回溯算法会舍弃它，并在前面的一些步骤做出一些修改，并重新尝试找到可行解。究其本质，其实就是枚举。
 
@@ -44,16 +47,17 @@ https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number
 - 遍历下一个数字所对应的所有映射的字母
 - 将当前的字母添加到组合最后，也就是 str + tmp[r]
 
-## 关键点
+### 关键点
 
 - 回溯
 - 回溯模板
 
-## 代码
+### 代码
 
 - 语言支持：JS, C++, Java, Python
 
 JavaScript Code:
+
 ```js
 /**
  * @param {string} digits
@@ -90,8 +94,8 @@ const letterCombinations = function (digits) {
 };
 ```
 
-
 C++ Code:
+
 ```c++
 class Solution {
 public:
@@ -126,6 +130,7 @@ public:
 ```
 
 Java Code:
+
 ```java
 class Solution {
 
@@ -172,6 +177,7 @@ class Solution {
 ```
 
 Python Code:
+
 ```py
 class Solution(object):
     def letterCombinations(self, digits):
@@ -186,7 +192,7 @@ class Solution(object):
         self.res = []
         self.dfs(digits, 0, "")
         return self.res
-    
+
     def dfs(self, digits, index, s):
         # 递归的终止条件,用index记录每次遍历到字符串的位置
         if index == len(digits):
@@ -207,8 +213,80 @@ class Solution(object):
 
 N + M 是输入数字的总数
 
-- 时间复杂度：O(3^N \* 4^M)
-- 空间复杂度：O(3^N \* 4^M)
+- 时间复杂度：O(2^N)，其中 N 为 digits 对于的所有可能的字母的和。
+- 空间复杂度：O(2^N)，其中 N 为 digits 对于的所有可能的字母的和。
+
+## 笛卡尔积
+
+### 思路
+
+不难发现， 题目要求的是一个笛卡尔积。
+
+比如 digits = 'ab'，其实就是 a 对应的集合 {'a', 'b', 'c'} 和 b 对应的集合 {'d', 'e', 'f'} 笛卡尔积。
+
+简单回忆一下笛卡尔积的内容。对于两个集合 A 和 B，A×B = {(x,y)|x∈A∧y∈B}。
+
+例如，A={a,b}, B={0,1,2}，则：
+
+- A×B={(a, 0), (a, 1), (a, 2), (b, 0), (b, 1), (b, 2)}
+- B×A={(0, a), (0, b), (1, a), (1, b), (2, a), (2, b)}
+
+实际上，力扣关于笛卡尔积优化的题目并不少。 比如：
+
+- [140. 单词拆分 II](https://github.com/azl397985856/fe-interview/issues/153)
+- [95. 不同的二叉搜索树 II](https://github.com/azl397985856/leetcode/blob/master/problems/95.unique-binary-search-trees-ii.md)
+- 96.unique-binary-search-trees
+- 等等
+
+知道了这一点之后，就不难写出如下代码。
+
+由于我们使用了笛卡尔积优化， 因此可以改造成纯函数，进而使用记忆化递归，进一步降低时间复杂度， 这是一个常见的优化技巧。
+
+### 关键点
+
+- 笛卡尔积
+- 记忆化递归
+
+### 代码
+
+代码支持：Python3
+
+```py
+
+# 输入："23"
+# 输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
+class Solution:
+    def letterCombinations(self, digits: str) -> List[str]:
+        mapper = [" ", " ", "abc", "def", "ghi",
+                  "jkl", "mno", "pqrs", "tuv", "wxyz"]
+		    @lru_cache(None)
+        def backtrack(digits, start):
+            if start >= len(digits):
+                return ['']
+            ans = []
+            for i in range(start, len(digits)):
+                for c in mapper[int(digits[i])]:
+                    # 笛卡尔积
+                    for p in backtrack(digits, i + 1):
+                        # 需要过滤诸如  "d", "e", "f" 等长度不符合的数据
+                        if start == 0:
+                            if len(c + p) == len(digits):
+                                ans.append(c + p)
+                        else:
+                            ans.append(c + p)
+            return ans
+        if not digits:
+            return []
+        return backtrack(digits, 0)
+
+```
+
+**复杂度分析**
+
+N + M 是输入数字的总数
+
+- 时间复杂度：O(N^2)，其中 N 为 digits 对于的所有可能的字母的和。
+- 空间复杂度：O(N^2)，其中 N 为 digits 对于的所有可能的字母的和。
 
 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。
 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。