feat: add solutions to lcci problem: No.17.22 (doocs#2812)

No.17.22.Word Transformer

Author: yanglbme

lcci/17.22.Word Transformer/README.md

@@ -33,7 +33,19 @@ wordList = ["hot","dot","dog","lot",&quo
 
 ## 解法
 
-### 方法一
+### 方法一：DFS
+
+我们定义一个答案数组 $\textit{ans}$，初始时只包含 $\textit{beginWord}$。然后我们定义一个数组 $\textit{vis}$，用来标记 $\textit{wordList}$ 中的单词是否被访问过。
+
+接下来，我们设计一个函数 $\text{dfs}(s)$，表示从 $\textit{s}$ 出发，尝试将 $\textit{s}$ 转换为 $\textit{endWord}$，是否能够成功。如果能够成功，返回 $\text{True}$，否则返回 $\text{False}$。
+
+函数 $\text{dfs}(s)$ 的具体实现如下：
+
+1. 如果 $\textit{s}$ 等于 $\textit{endWord}$，说明转换成功，返回 $\text{True}$；
+2. 否则，我们遍历 $\textit{wordList}$ 中的每个单词 $\textit{t}$，如果 $\textit{t}$ 没有被访问过且 $\textit{s}$ 和 $\textit{t}$ 之间只有一个字符不同，那么我们将 $\textit{t}$ 标记为已访问，并将 $\textit{t}$ 加入到 $\textit{ans}$ 中，然后递归调用 $\text{dfs}(t)$，如果返回 $\text{True}$，说明转换成功，我们返回 $\text{True}$，否则我们将 $\textit{t}$ 从 $\textit{ans}$ 中移除，继续遍历下一个单词；
+3. 如果遍历完 $\textit{wordList}$ 中的所有单词都没有找到可以转换的单词，说明转换失败，我们返回 $\text{False}$。
+
+最后，我们调用 $\text{dfs}(\textit{beginWord})$，如果返回 $\text{True}$，说明转换成功，我们返回 $\textit{ans}$，否则返回空数组。
 
 <!-- tabs:start -->
 
@@ -42,72 +54,67 @@ class Solution:
     def findLadders(
         self, beginWord: str, endWord: str, wordList: List[str]
     ) -> List[str]:
-        def check(a, b):
-            return sum(a[i] != b[i] for i in range(len(a))) == 1
-
-        def dfs(begin, end, t):
-            nonlocal ans
-            if ans:
-                return
-            if begin == end:
-                ans = t.copy()
-                return
-            for word in wordList:
-                if word in visited or not check(begin, word):
-                    continue
-                visited.add(word)
-                t.append(word)
-                dfs(word, end, t)
-                t.pop()
-
-        ans = []
-        visited = set()
-        dfs(beginWord, endWord, [beginWord])
-        return ans
+        def check(s: str, t: str) -> bool:
+            return len(s) == len(t) and sum(a != b for a, b in zip(s, t)) == 1
+
+        def dfs(s: str) -> bool:
+            if s == endWord:
+                return True
+            for i, t in enumerate(wordList):
+                if not vis[i] and check(s, t):
+                    vis[i] = True
+                    ans.append(t)
+                    if dfs(t):
+                        return True
+                    ans.pop()
+            return False
+
+        ans = [beginWord]
+        vis = [False] * len(wordList)
+        return ans if dfs(beginWord) else []
 ```
 
 ```java
 class Solution {
-    private List<String> words;
-    private List<String> ans;
-    private Set<String> visited;
+    private List<String> ans = new ArrayList<>();
+    private List<String> wordList;
+    private String endWord;
+    private boolean[] vis;
 
     public List<String> findLadders(String beginWord, String endWord, List<String> wordList) {
-        words = wordList;
-        ans = new ArrayList<>();
-        visited = new HashSet<>();
-        List<String> t = new ArrayList<>();
-        t.add(beginWord);
-        dfs(beginWord, endWord, t);
-        return ans;
+        this.wordList = wordList;
+        this.endWord = endWord;
+        ans.add(beginWord);
+        vis = new boolean[wordList.size()];
+        return dfs(beginWord) ? ans : List.of();
     }
 
-    private void dfs(String begin, String end, List<String> t) {
-        if (!ans.isEmpty()) {
-            return;
+    private boolean dfs(String s) {
+        if (s.equals(endWord)) {
+            return true;
         }
-        if (Objects.equals(begin, end)) {
-            ans = new ArrayList<>(t);
-            return;
-        }
-        for (String word : words) {
-            if (visited.contains(word) || !check(begin, word)) {
+        for (int i = 0; i < wordList.size(); ++i) {
+            String t = wordList.get(i);
+            if (vis[i] || !check(s, t)) {
                 continue;
             }
-            t.add(word);
-            visited.add(word);
-            dfs(word, end, t);
-            t.remove(t.size() - 1);
+            vis[i] = true;
+            ans.add(t);
+            if (dfs(t)) {
+                return true;
+            }
+            ans.remove(ans.size() - 1);
         }
+        return false;
     }
 
-    private boolean check(String a, String b) {
-        if (a.length() != b.length()) {
+    private boolean check(String s, String t) {
+        if (s.length() != t.length()) {
             return false;
         }
         int cnt = 0;
-        for (int i = 0; i < a.length(); ++i) {
-            if (a.charAt(i) != b.charAt(i)) {
+        for (int i = 0; i < s.length(); ++i) {
+            if (s.charAt(i) != t.charAt(i)) {
                 ++cnt;
             }
         }
@@ -119,87 +126,128 @@ class Solution {
 ```cpp
 class Solution {
 public:
-    vector<string> words;
-    vector<string> ans;
-    unordered_set<string> visited;
-
     vector<string> findLadders(string beginWord, string endWord, vector<string>& wordList) {
-        this->words = wordList;
-        ans.resize(0);
-        vector<string> t;
-        t.push_back(beginWord);
-        dfs(beginWord, endWord, t);
-        return ans;
+        this->endWord = move(endWord);
+        this->wordList = move(wordList);
+        vis.resize(this->wordList.size(), false);
+        ans.push_back(beginWord);
+        if (dfs(beginWord)) {
+            return ans;
+        }
+        return {};
     }
 
-    void dfs(string begin, string end, vector<string>& t) {
-        if (!ans.empty()) return;
-        if (begin == end) {
-            ans = t;
-            return;
+private:
+    vector<string> ans;
+    vector<bool> vis;
+    string endWord;
+    vector<string> wordList;
+
+    bool check(string& s, string& t) {
+        if (s.size() != t.size()) {
+            return false;
         }
-        for (auto word : words) {
-            if (visited.count(word) || !check(begin, word)) continue;
-            visited.insert(word);
-            t.push_back(word);
-            dfs(word, end, t);
-            t.pop_back();
+        int cnt = 0;
+        for (int i = 0; i < s.size(); ++i) {
+            cnt += s[i] != t[i];
         }
+        return cnt == 1;
     }
 
-    bool check(string a, string b) {
-        if (a.size() != b.size()) return false;
-        int cnt = 0;
-        for (int i = 0; i < a.size(); ++i)
-            if (a[i] != b[i]) ++cnt;
-        return cnt == 1;
+    bool dfs(string& s) {
+        if (s == endWord) {
+            return true;
+        }
+        for (int i = 0; i < wordList.size(); ++i) {
+            string& t = wordList[i];
+            if (!vis[i] && check(s, t)) {
+                vis[i] = true;
+                ans.push_back(t);
+                if (dfs(t)) {
+                    return true;
+                }
+                ans.pop_back();
+            }
+        }
+        return false;
     }
 };
 ```
 
 ```go
 func findLadders(beginWord string, endWord string, wordList []string) []string {
-	var ans []string
-	visited := make(map[string]bool)
-
-	check := func(a, b string) bool {
-		if len(a) != len(b) {
+	ans := []string{beginWord}
+	vis := make([]bool, len(wordList))
+	check := func(s, t string) bool {
+		if len(s) != len(t) {
 			return false
 		}
 		cnt := 0
-		for i := 0; i < len(a); i++ {
-			if a[i] != b[i] {
+		for i := range s {
+			if s[i] != t[i] {
 				cnt++
 			}
 		}
 		return cnt == 1
 	}
-
-	var dfs func(begin, end string, t []string)
-	dfs = func(begin, end string, t []string) {
-		if len(ans) > 0 {
-			return
-		}
-		if begin == end {
-			ans = make([]string, len(t))
-			copy(ans, t)
-			return
+	var dfs func(s string) bool
+	dfs = func(s string) bool {
+		if s == endWord {
+			return true
 		}
-		for _, word := range wordList {
-			if visited[word] || !check(begin, word) {
-				continue
+		for i, t := range wordList {
+			if !vis[i] && check(s, t) {
+				vis[i] = true
+				ans = append(ans, t)
+				if dfs(t) {
+					return true
+				}
+				ans = ans[:len(ans)-1]
 			}
-			t = append(t, word)
-			visited[word] = true
-			dfs(word, end, t)
-			t = t[:len(t)-1]
 		}
+		return false
 	}
+	if dfs(beginWord) {
+		return ans
+	}
+	return []string{}
+}
+```
 
-	var t []string
-	t = append(t, beginWord)
-	dfs(beginWord, endWord, t)
-	return ans
+```ts
+function findLadders(beginWord: string, endWord: string, wordList: string[]): string[] {
+    const ans: string[] = [beginWord];
+    const vis: boolean[] = Array(wordList.length).fill(false);
+    const check = (s: string, t: string): boolean => {
+        if (s.length !== t.length) {
+            return false;
+        }
+        let cnt = 0;
+        for (let i = 0; i < s.length; ++i) {
+            if (s[i] !== t[i]) {
+                ++cnt;
+            }
+        }
+        return cnt === 1;
+    };
+    const dfs = (s: string): boolean => {
+        if (s === endWord) {
+            return true;
+        }
+        for (let i = 0; i < wordList.length; ++i) {
+            const t: string = wordList[i];
+            if (!vis[i] && check(s, t)) {
+                vis[i] = true;
+                ans.push(t);
+                if (dfs(t)) {
+                    return true;
+                }
+                ans.pop();
+            }
+        }
+        return false;
+    };
+    return dfs(beginWord) ? ans : [];
 }
 ```