Merge branch 'doocs:main' into main

Author: Nothing-avil

solution/0000-0099/0091.Decode Ways/README_EN.md

@@ -17,52 +17,66 @@ tags:
 
 <!-- description:start -->
 
-<p>A message containing letters from <code>A-Z</code> can be <strong>encoded</strong> into numbers using the following mapping:</p>
+<p>You have intercepted a secret message encoded as a string of numbers. The message is <strong>decoded</strong> via the following mapping:</p>
 
-<pre>
-&#39;A&#39; -&gt; &quot;1&quot;
-&#39;B&#39; -&gt; &quot;2&quot;
-...
-&#39;Z&#39; -&gt; &quot;26&quot;
-</pre>
+<p><code>&quot;1&quot; -&gt; &#39;A&#39;<br />
+&quot;2&quot; -&gt; &#39;B&#39;<br />
+...<br />
+&quot;25&quot; -&gt; &#39;Y&#39;<br />
+&quot;26&quot; -&gt; &#39;Z&#39;</code></p>
 
-<p>To <strong>decode</strong> an encoded message, all the digits must be grouped then mapped back into letters using the reverse of the mapping above (there may be multiple ways). For example, <code>&quot;11106&quot;</code> can be mapped into:</p>
+<p>However, while decoding the message, you realize that there are many different ways you can decode the message because some codes are contained in other codes (<code>&quot;2&quot;</code> and <code>&quot;5&quot;</code> vs <code>&quot;25&quot;</code>).</p>
+
+<p>For example, <code>&quot;11106&quot;</code> can be decoded into:</p>
 
 <ul>
-	<li><code>&quot;AAJF&quot;</code> with the grouping <code>(1 1 10 6)</code></li>
-	<li><code>&quot;KJF&quot;</code> with the grouping <code>(11 10 6)</code></li>
+	<li><code>&quot;AAJF&quot;</code> with the grouping <code>(1, 1, 10, 6)</code></li>
+	<li><code>&quot;KJF&quot;</code> with the grouping <code>(11, 10, 6)</code></li>
+	<li>The grouping <code>(1, 11, 06)</code> is invalid because <code>&quot;06&quot;</code> is not a valid code (only <code>&quot;6&quot;</code> is valid).</li>
 </ul>
 
-<p>Note that the grouping <code>(1 11 06)</code> is invalid because <code>&quot;06&quot;</code> cannot be mapped into <code>&#39;F&#39;</code> since <code>&quot;6&quot;</code> is different from <code>&quot;06&quot;</code>.</p>
-
-<p>Given a string <code>s</code> containing only digits, return <em>the <strong>number</strong> of ways to <strong>decode</strong> it</em>.</p>
+<p>Note: there may be strings that are impossible to decode.<br />
+<br />
+Given a string s containing only digits, return the <strong>number of ways</strong> to <strong>decode</strong> it. If the entire string cannot be decoded in any valid way, return <code>0</code>.</p>
 
 <p>The test cases are generated so that the answer fits in a <strong>32-bit</strong> integer.</p>
 
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>
 
-<pre>
-<strong>Input:</strong> s = &quot;12&quot;
-<strong>Output:</strong> 2
-<strong>Explanation:</strong> &quot;12&quot; could be decoded as &quot;AB&quot; (1 2) or &quot;L&quot; (12).
-</pre>
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">s = &quot;12&quot;</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">2</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>&quot;12&quot; could be decoded as &quot;AB&quot; (1 2) or &quot;L&quot; (12).</p>
+</div>
 
 <p><strong class="example">Example 2:</strong></p>
 
-<pre>
-<strong>Input:</strong> s = &quot;226&quot;
-<strong>Output:</strong> 3
-<strong>Explanation:</strong> &quot;226&quot; could be decoded as &quot;BZ&quot; (2 26), &quot;VF&quot; (22 6), or &quot;BBF&quot; (2 2 6).
-</pre>
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">s = &quot;226&quot;</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">3</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>&quot;226&quot; could be decoded as &quot;BZ&quot; (2 26), &quot;VF&quot; (22 6), or &quot;BBF&quot; (2 2 6).</p>
+</div>
 
 <p><strong class="example">Example 3:</strong></p>
 
-<pre>
-<strong>Input:</strong> s = &quot;06&quot;
-<strong>Output:</strong> 0
-<strong>Explanation:</strong> &quot;06&quot; cannot be mapped to &quot;F&quot; because of the leading zero (&quot;6&quot; is different from &quot;06&quot;).
-</pre>
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">s = &quot;06&quot;</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">0</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>&quot;06&quot; cannot be mapped to &quot;F&quot; because of the leading zero (&quot;6&quot; is different from &quot;06&quot;). In this case, the string is not a valid encoding, so return 0.</p>
+</div>
 
 <p>&nbsp;</p>
 <p><strong>Constraints:</strong></p>

solution/0300-0399/0332.Reconstruct Itinerary/README.md

@@ -64,7 +64,13 @@ tags:
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：欧拉路径
+
+题目实际上是给定 $n$ 个点和 $m$ 条边，要求从指定的起点出发，经过所有的边恰好一次，使得路径字典序最小。这是一个典型的欧拉路径问题。
+
+由于本题保证了至少存在一种合理的行程，因此，我们直接利用 Hierholzer 算法，输出从起点出发的欧拉路径即可。
+
+时间复杂度 $O(m \times \log m)$，空间复杂度 $O(m)$。其中 $m$ 是边的数量。
 
 <!-- tabs:start -->
 
@@ -73,56 +79,43 @@ tags:
 ```python
 class Solution:
     def findItinerary(self, tickets: List[List[str]]) -> List[str]:
-        graph = defaultdict(list)
-
-        for src, dst in sorted(tickets, reverse=True):
-            graph[src].append(dst)
-
-        itinerary = []
-
-        def dfs(airport):
-            while graph[airport]:
-                dfs(graph[airport].pop())
-            itinerary.append(airport)
-
+        def dfs(f: str):
+            while g[f]:
+                dfs(g[f].pop())
+            ans.append(f)
+
+        g = defaultdict(list)
+        for f, t in sorted(tickets, reverse=True):
+            g[f].append(t)
+        ans = []
         dfs("JFK")
-
-        return itinerary[::-1]
+        return ans[::-1]
 ```
 
 #### Java
 
 ```java
 class Solution {
-    void dfs(Map<String, Queue<String>> adjLists, List<String> ans, String curr) {
-        Queue<String> neighbors = adjLists.get(curr);
-        if (neighbors == null) {
-            ans.add(curr);
-            return;
-        }
-        while (!neighbors.isEmpty()) {
-            String neighbor = neighbors.poll();
-            dfs(adjLists, ans, neighbor);
-        }
-        ans.add(curr);
-        return;
-    }
+    private Map<String, List<String>> g = new HashMap<>();
+    private List<String> ans = new ArrayList<>();
 
     public List<String> findItinerary(List<List<String>> tickets) {
-        Map<String, Queue<String>> adjLists = new HashMap<>();
+        Collections.sort(tickets, (a, b) -> b.get(1).compareTo(a.get(1)));
         for (List<String> ticket : tickets) {
-            String from = ticket.get(0);
-            String to = ticket.get(1);
-            if (!adjLists.containsKey(from)) {
-                adjLists.put(from, new PriorityQueue<>());
-            }
-            adjLists.get(from).add(to);
+            g.computeIfAbsent(ticket.get(0), k -> new ArrayList<>()).add(ticket.get(1));
         }
-        List<String> ans = new ArrayList<>();
-        dfs(adjLists, ans, "JFK");
+        dfs("JFK");
         Collections.reverse(ans);
         return ans;
     }
+
+    private void dfs(String f) {
+        while (g.containsKey(f) && !g.get(f).isEmpty()) {
+            String t = g.get(f).remove(g.get(f).size() - 1);
+            dfs(t);
+        }
+        ans.add(f);
+    }
 }
 ```
 
@@ -132,36 +125,77 @@ class Solution {
 class Solution {
 public:
     vector<string> findItinerary(vector<vector<string>>& tickets) {
-        unordered_map<string, priority_queue<string, vector<string>, greater<string>>> g;
-        vector<string> ret;
-
-        // Initialize the graph
-        for (const auto& t : tickets) {
-            g[t[0]].push(t[1]);
+        sort(tickets.rbegin(), tickets.rend());
+        unordered_map<string, vector<string>> g;
+        for (const auto& ticket : tickets) {
+            g[ticket[0]].push_back(ticket[1]);
         }
+        vector<string> ans;
+        auto dfs = [&](auto&& dfs, string& f) -> void {
+            while (!g[f].empty()) {
+                string t = g[f].back();
+                g[f].pop_back();
+                dfs(dfs, t);
+            }
+            ans.emplace_back(f);
+        };
+        string f = "JFK";
+        dfs(dfs, f);
+        reverse(ans.begin(), ans.end());
+        return ans;
+    }
+};
+```
 
-        findItineraryInner(g, ret, "JFK");
+#### Go
+
+```go
+func findItinerary(tickets [][]string) (ans []string) {
+	sort.Slice(tickets, func(i, j int) bool {
+		return tickets[i][0] > tickets[j][0] || (tickets[i][0] == tickets[j][0] && tickets[i][1] > tickets[j][1])
+	})
+	g := make(map[string][]string)
+	for _, ticket := range tickets {
+		g[ticket[0]] = append(g[ticket[0]], ticket[1])
+	}
+	var dfs func(f string)
+	dfs = func(f string) {
+		for len(g[f]) > 0 {
+			t := g[f][len(g[f])-1]
+			g[f] = g[f][:len(g[f])-1]
+			dfs(t)
+		}
+		ans = append(ans, f)
+	}
+	dfs("JFK")
+	for i := 0; i < len(ans)/2; i++ {
+		ans[i], ans[len(ans)-1-i] = ans[len(ans)-1-i], ans[i]
+	}
+	return
+}
+```
 
-        ret = {ret.rbegin(), ret.rend()};
+#### TypeScript
 
-        return ret;
+```ts
+function findItinerary(tickets: string[][]): string[] {
+    const g: Record<string, string[]> = {};
+    tickets.sort((a, b) => b[1].localeCompare(a[1]));
+    for (const [f, t] of tickets) {
+        g[f] = g[f] || [];
+        g[f].push(t);
     }
-
-    void findItineraryInner(unordered_map<string, priority_queue<string, vector<string>, greater<string>>>& g, vector<string>& ret, string cur) {
-        if (g.count(cur) == 0) {
-            // This is the end point
-            ret.push_back(cur);
-            return;
-        } else {
-            while (!g[cur].empty()) {
-                auto front = g[cur].top();
-                g[cur].pop();
-                findItineraryInner(g, ret, front);
-            }
-            ret.push_back(cur);
+    const ans: string[] = [];
+    const dfs = (f: string) => {
+        while (g[f] && g[f].length) {
+            const t = g[f].pop()!;
+            dfs(t);
         }
-    }
-};
+        ans.push(f);
+    };
+    dfs('JFK');
+    return ans.reverse();
+}
 ```
 
 <!-- tabs:end -->