797. （有向无环图）所有可能的路径（M）/ 1575. （汽车加油）统计所有可行路径（H）/ 332. 重新安排行程（H）/ 752 打开转盘锁 / 753. 破解保险箱（H）（欧拉回路！！）

• 题解
  

class Solution:
    def allPathsSourceTarget(self, graph: List[List[int]]) -> List[List[int]]:
        res = []
        path = [0] # 每条路径都从第0个节点开始

        def dfs(x: int):
            # 若已经到达第n-1个节点，则找到一条路径
            if x == len(graph) - 1:
                res.append(path[:])
                return
            
            # 对当前节点中的所有后续节点进行深度遍历
            for y in graph[x]:
                path.append(y)
                dfs(y)
                path.pop()
        
        dfs(0)

        return res

1575. 统计所有可行路径

• Python记忆化搜索 击败97.78%的用户, 注意细节
  

class Solution:
	# 记忆化搜索（更快）
    def countRoutes(self, locations: List[int], start: int, finish: int, fuel: int) -> int:
        n = len(locations)
        MOD = 10 ** 9 + 7

        # 预处理: 计算两两城市间的距离, 否则的话, 一对城市间的距离会重复计算多遍
        d = [[0] * n for _ in range(n)]
        for i in range(n):
            for j in range(i):
                d[i][j] = d[j][i] = abs(locations[i] - locations[j])

        @lru_cache(None)
        def dfs(i, fuel):
            if i == finish:
                ans = 1
            else:
                ans = 0

            if fuel == 0:
                return ans

            # 剪枝: 如果目前的位置已经无法达到终点了, 提早终止
            if d[i][finish] > fuel:
                return ans
                
            for j in range(n):
                if j == i: continue
                dist = D[i][j]
                if fuel >= dist:
                    ans += dfs(j, fuel - dist)

            return ans % MOD

        return dfs(start, fuel)

class Solution:
	# 动态规划
    def countRoutes(self, locations: List[int], start: int, finish: int, fuel: int) -> int:
        n = len(locations)
        mod = 1e9+7

        # dp[i][j]表示到达第i个城市，消耗油量j的路径数量
        dp = [[0 for _ in range(fuel + 1)] for _ in range(n)]
        dp[start][0] = 1 # 到达start，花费燃料为0，方案数为1

        for f in range(0, fuel + 1):
        	# 下面两个循环表示遍历每两个城市i、j（注意：这里的i、j不表示第i个城市、消耗油量j！）
            for i in range(n):
                for j in range(n):
                    # 若为同一个城市(i=j)，则跳过
                    if i == j: continue
                    
                    cost = abs(locations[i] - locations[j])
                    if f + cost <= fuel:
                        # 花费燃料从城市i走到城市j的转移方程, 可以想象成树，同一个节点有很多个子节点。
                        dp[j][f + cost] += dp[i][f] 
                        dp[j][f + cost] %= mod

        res = 0
        # 遍历所有到达了终点，并且燃料用完/没用完的路径
        for f in range(fuel + 1):
            res += dp[finish][f]
            res %= mod

        return int(res)

332. 重新安排行程

• 题解1：DFS（超时！）
• 题解2：欧拉图
  

class Solution:
    def findItinerary(self, tickets: List[List[str]]) -> List[str]:
        def dfs(curr: str):
            while vec[curr]:
                tmp = heapq.heappop(vec[curr])
                dfs(tmp)
            stack.append(curr)

        vec = collections.defaultdict(list)
        for depart, arrive in tickets:
            vec[depart].append(arrive)
        for key in vec:
            heapq.heapify(vec[key])
        
        stack = list()
        dfs("JFK")
        return stack[::-1]

752. 打开转盘锁

• 官方题解（2种方法）
  
• 为什么这题要用 BFS(广度优先搜索) ？根据题意，我们需要找到最少的解锁步数，这实际上可以认为是在图上搜索最短路径。BFS 总是优先搜索距离根节点近的节点，因此它搜索到的路径就是最短路径（以当前锁上的数字为根，所有能达到的数字为一阶邻域（子节点）进行搜索）

from queue import Queue

class Solution:
    def openLock(self, deadends: List[str], target: str) -> int:
        if '0000' == target:
            return 0

        deadends = set(deadends) # in 操作在set中时间复杂度为O(1)
        if '0000' in deadends:
            return -1
        
        # 初始化根节点
        q = Queue()
        q.put(('0000', 0)) # (当前节点值，转动步数)
        
        # 开始循环队列
        while not q.empty():
            
            # 取出一个节点
            node, step = q.get()
            
            # 放入周围节点
            for i in range(4):
                # 每次转动可视为有左、右2个方向
                for add in (1, -1):
                    cur = node[:i] + str((int(node[i]) + add) % 10) + node[i+1:]
                    if cur == target:
                        return step + 1
                        
                    if not cur in deadends:
                        q.put((cur, step + 1))
                        deadends.add(cur) # 避免重复搜索
        
        return -1

753. 破解保险箱

• 题解
  

class Solution:
    def crackSafe(self, n: int, k: int) -> str:
        visited = set()
        ans = list()
        highest = 10 ** (n - 1)

        def dfs(node):
            for x in range(k):
                nei = node * 10 + x
                if nei not in visited:
                    visited.add(nei)
                    dfs(nei % highest)
                    ans.append(str(x))

        dfs(0)
        return "".join(ans) + "0" * (n - 1)