From 498395d07a6363198a99a530555c768432f1148d Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Sat, 27 May 2023 22:18:11 -0500
Subject: [PATCH] =?UTF-8?q?Update=200332.=E9=87=8D=E6=96=B0=E5=AE=89?=
 =?UTF-8?q?=E6=8E=92=E8=A1=8C=E7=A8=8B.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0332.重新安排行程.md | 126 +++++++++++++++++-----------
 1 file changed, 75 insertions(+), 51 deletions(-)

diff --git a/problems/0332.重新安排行程.md b/problems/0332.重新安排行程.md
index 95e7d3ed..fa6414e9 100644
--- a/problems/0332.重新安排行程.md
+++ b/problems/0332.重新安排行程.md
@@ -347,64 +347,88 @@ class Solution {
 ```
 
 ### python 
+回溯 使用used数组 
 
 ```python
 class Solution:
     def findItinerary(self, tickets: List[List[str]]) -> List[str]:
-        # defaultdic(list) 是为了方便直接append
-        tickets_dict = defaultdict(list)
-        for item in tickets:
-            tickets_dict[item[0]].append(item[1])
-	# 给每一个机场的到达机场排序，小的在前面，在回溯里首先被pop(0）出去
-	# 这样最先找的的path就是排序最小的答案，直接返回
-	for airport in tickets_dict: tickets_dict[airport].sort()
-        '''
-        tickets_dict里面的内容是这样的
-         {'JFK': ['ATL', 'SFO'], 'SFO': ['ATL'], 'ATL': ['JFK', 'SFO']})
-        '''
-        path = ["JFK"]
-        def backtracking(start_point):
-            # 终止条件
-            if len(path) == len(tickets) + 1:
-                return True
-            for _ in tickets_dict[start_point]:
-                #必须及时删除，避免出现死循环
-                end_point = tickets_dict[start_point].pop(0)
-                path.append(end_point)
-                # 只要找到一个就可以返回了
-                if backtracking(end_point):
-                    return True
-                path.pop()
-                tickets_dict[start_point].append(end_point)
-
-        backtracking("JFK")
-        return path
-```
-	
-python  - 使用used数组 - 神似之前几题写法
-
-```python	
-class Solution:
-    def findItinerary(self, tickets: List[List[str]]) -> List[str]:
-        global used,path,results
-        used = [0]*len(tickets)
+        tickets.sort() # 先排序，这样一旦找到第一个可行路径，一定是字母排序最小的
+        used = [0] * len(tickets)
         path = ['JFK']
         results = []
-        tickets.sort() # 先排序，这样一旦找到第一个可行路径，一定是字母排序最小的
-        self.backtracking(tickets,'JFK')
+        self.backtracking(tickets, used, path, 'JFK', results)
         return results[0]
-    def backtracking(self,tickets,cur):
-        if sum(used) == len(tickets):
-            results.append(path[:])
-            return True # 只要找到就返回
-        for i in range(len(tickets)):
-            if tickets[i][0]==cur and used[i]==0:
-                used[i]=1
-                path.append(tickets[i][1])
-                state = self.backtracking(tickets,tickets[i][1])
-                path.pop()
-                used[i]=0
-                if state: return True # 只要找到就返回，不继续搜索了
+    
+    def backtracking(self, tickets, used, path, cur, results):
+        if len(path) == len(tickets) + 1:  # 终止条件：路径长度等于机票数量+1
+            results.append(path[:])  # 将当前路径添加到结果列表
+            return True
+        
+        for i, ticket in enumerate(tickets):  # 遍历机票列表
+            if ticket[0] == cur and used[i] == 0:  # 找到起始机场为cur且未使用过的机票
+                used[i] = 1  # 标记该机票为已使用
+                path.append(ticket[1])  # 将到达机场添加到路径中
+                state = self.backtracking(tickets, used, path, ticket[1], results)  # 递归搜索
+                path.pop()  # 回溯，移除最后添加的到达机场
+                used[i] = 0  # 标记该机票为未使用
+                if state:
+                    return True  # 只要找到一个可行路径就返回，不继续搜索
+
+```
+回溯 使用字典
+```python	
+from collections import defaultdict
+
+class Solution:
+    def findItinerary(self, tickets: List[List[str]]) -> List[str]:
+        targets = defaultdict(list)  # 构建机场字典
+        for ticket in tickets:
+            targets[ticket[0]].append(ticket[1])
+        for airport in targets:
+            targets[airport].sort()  # 对目的地列表进行排序
+
+        path = ["JFK"]  # 起始机场为"JFK"
+        self.backtracking(targets, path, len(tickets))
+        return path
+
+    def backtracking(self, targets, path, ticketNum):
+        if len(path) == ticketNum + 1:
+            return True  # 找到有效行程
+
+        airport = path[-1]  # 当前机场
+        destinations = targets[airport]  # 当前机场可以到达的目的地列表
+        for i, dest in enumerate(destinations):
+            targets[airport].pop(i)  # 标记已使用的机票
+            path.append(dest)  # 添加目的地到路径
+            if self.backtracking(targets, path, ticketNum):
+                return True  # 找到有效行程
+            targets[airport].insert(i, dest)  # 回溯，恢复机票
+            path.pop()  # 移除目的地
+        return False  # 没有找到有效行程
+
+```	
+回溯 使用字典 逆序
+```python	
+from collections import defaultdict
+
+class Solution:
+    def findItinerary(self, tickets):
+        targets = defaultdict(list)  # 创建默认字典，用于存储机场映射关系
+        for ticket in tickets:
+            targets[ticket[0]].append(ticket[1])  # 将机票输入到字典中
+        
+        for key in targets:
+            targets[key].sort(reverse=True)  # 对到达机场列表进行字母逆序排序
+        
+        result = []
+        self.backtracking("JFK", targets, result)  # 调用回溯函数开始搜索路径
+        return result[::-1]  # 返回逆序的行程路径
+    
+    def backtracking(self, airport, targets, result):
+        while targets[airport]:  # 当机场还有可到达的机场时
+            next_airport = targets[airport].pop()  # 弹出下一个机场
+            self.backtracking(next_airport, targets, result)  # 递归调用回溯函数进行深度优先搜索
+        result.append(airport)  # 将当前机场添加到行程路径中
 ```
 	
 ### GO