LeetCode1786:从第一个节点出发到最后一个节点的受限路径数(dijkstra + 记忆化搜索)

 

 解题思路:比赛的是没读懂题意,这题求的是起点1到n路径序列数,但是路径序列上的相邻两个点 i, i+1 之间应该满足 i、i+1 到终点的最短路low[i] > low[i+1]。

因此需要先以终点开始,跑一遍dijkstra算法,考虑时间复杂度,使用邻接表加优先队列优化。计算得到最短路 low 数组,从起点dfs到终点的路径数量,对于 i 节点,它到终点的路径数 dp[i] = sum(dp[ j ]) ( j 是满足受限条件的下一个节点 j,dp[j] 表示 j 到终点的路径数);考虑到得数需要模1e7+7,因此可能会重复访问某个节点,因此用dp[i] 数组保存节点 i 到终点的路径数,减少重复的dfs次数。

(ps:用python写的代码似乎有递归深度的限制,在一番折腾无解后,我用栈模拟了 dfs 过程。)

复制代码
 1 class Node(object):
 2     def __init__(self,x,y):
 3         self.id = x
 4         self.dis = y
 5 
 6     def __lt__(self, other):        #定义了<,像C++的重载<运算符
 7         return self.dis<other.dis
 8 
 9 
10 import heapq
11 class PriorityQueue(object):
12     def __init__(self):
13         self._queue = []
14         self._index = 0
15     def push(self, item, priority):
16         # 传入两个参数,一个是存放元素的数组,另一个是要存储的元素,这里是一个元组。
17         # 由于heap内部默认有小到大排,如果要从大到小排,就要对priority取负数
18         heapq.heappush(self._queue, (priority, self._index, item))
19         self._index += 1
20     def pop(self):
21         return heapq.heappop(self._queue)[-1]
22     def empty(self):
23         return not bool(len(self._queue))
24 
25 class Solution(object):
26     def dij(self,n,vec):
27         inf = int(1e9)
28         used = [0]*n
29         low = [inf]*n
30         for i in range(n):
31             low[i] = inf
32         low[-1]=0
33         pq = PriorityQueue()
34         start = n-1
35         pq.push(start,low[n-1])
36         x= 0
37         while not pq.empty():
38             if x>=n:
39                 break
40             now = pq.pop()
41             x+=1
42             #print(now.id)
43             for nxt in vec[now]:
44                 if low[nxt.id] > low[now] + nxt.dis:
45                     low[nxt.id] = low[now] + nxt.dis
46                     pq.push(nxt.id,low[nxt.id])
47 
48         return low
49 
50     def countRestrictedPaths(self, n, edges):
51         sys.setrecursionlimit(100000)
52         inf = int(1e9)
53         vec = [[] for i in range(n)]
54         for edge in edges:
55             [s1,s2,w] = edge
56             n1,n2 = Node(s2-1,w),Node(s1-1,w)
57             vec[s1-1].append(n1)
58             vec[s2-1].append(n2)
59         #print(dis)
60         low = self.dij(n,vec)
61         #print('aaa')
62         dp = [0]*n
63         used = [0]*n
64         used[0] = 1
65         stack = [0]
66         while len(stack) >0:
67             top = stack.pop()
68             #print(stack)
69             stack.append(top)
70             if top == n-1: #终止条件
71                 _ = stack.pop()
72                 dp[top] = 1
73                 used[top] = 0
74                 continue
75             cnt = 0
76             flag = True
77             for nxt in vec[top]:
78                 i = nxt.id
79                 if low[top] > low[i] and used[i]==0:
80                     if dp[i] == 0: #说明没有访问过,加入栈
81                         #print('aaa',i)
82                         used[i]=1
83                         stack.append(i)
84                         flag = False
85                         break
86                     else:
87                         cnt= (cnt+dp[i])%(inf+7)
88             if not flag: #说明要继续搜索,当前状态不弹出
89                 continue
90             dp[top] = cnt #记忆
91             _ = stack.pop()
92             used[top]=0
93         #print(self.dp)
94         #print(low)
95         return dp[0]
复制代码

 

posted @   ISGuXing  阅读(246)  评论(0编辑  收藏  举报
编辑推荐:
· DeepSeek 解答了困扰我五年的技术问题
· 为什么说在企业级应用开发中,后端往往是效率杀手?
· 用 C# 插值字符串处理器写一个 sscanf
· Java 中堆内存和栈内存上的数据分布和特点
· 开发中对象命名的一点思考
阅读排行:
· PPT革命!DeepSeek+Kimi=N小时工作5分钟完成?
· What?废柴, 还在本地部署DeepSeek吗?Are you kidding?
· DeepSeek企业级部署实战指南:从服务器选型到Dify私有化落地
· 程序员转型AI:行业分析
· 重磅发布!DeepSeek 微调秘籍揭秘,一键解锁升级版全家桶,AI 玩家必备神器!
点击右上角即可分享
微信分享提示