Starting with an undirected graph (the "original graph") with nodes from 0 to N-1, subdivisions are made to some of the edges.
The graph is given as follows: edges[k] is a list of integer pairs (i, j, n) such that (i, j) is an edge of the original graph,
and n is the total number of new nodes on that edge.
Then, the edge (i, j) is deleted from the original graph, n new nodes (x_1, x_2, ..., x_n) are added to the original graph,
and n+1 new edges (i, x_1), (x_1, x_2), (x_2, x_3), ..., (x_{n-1}, x_n), (x_n, j) are added to the original graph.
Now, you start at node 0 from the original graph, and in each move, you travel along one edge.
Return how many nodes you can reach in at most M moves.
Example 1:
Input: edges = [[0,1,10],[0,2,1],[1,2,2]], M = 6, N = 3
Output: 13
Explanation:
The nodes that are reachable in the final graph after M = 6 moves are indicated below.
Example 2:
Input: edges = [[0,1,4],[1,2,6],[0,2,8],[1,3,1]], M = 10, N = 4
Output: 23
Note:
0 <= edges.length <= 100000 <= edges[i][0] < edges[i][1] < N- There does not exist any
i != jfor whichedges[i][0] == edges[j][0]andedges[i][1] == edges[j][1]. - The original graph has no parallel edges.
0 <= edges[i][2] <= 100000 <= M <= 10^91 <= N <= 3000- A reachable node is a node that can be travelled to using at most M moves starting from node 0.
单源最短路径,注意不要重复计算
class Solution:
def reachableNodes(self, edges, M, N):
"""
:type edges: List[List[int]]
:type M: int
:type N: int
:rtype: int
"""
import heapq
a=[[-1 for _ in range(N)] for _ in range(N)]
for s,t,n in edges: a[s][t]=a[t][s]=n
res=0
pq=[]
vis=[False for _ in range(N)]
heapq.heappush(pq, (-M,0))
while pq:
m,s = heapq.heappop(pq)
m=-m
if vis[s]: continue
vis[s]=True
res+=1
for i in range(N):
if a[s][i]<0: continue
if m>a[s][i] and not vis[i]: heapq.heappush(pq, (-(m-a[s][i]-1),i))
# some node between s and i are used
a[i][s] -= min(m, a[s][i])
res+=min(m, a[s][i])
return res
最后
以上就是诚心月饼最近收集整理的关于886. Reachable Nodes In Subdivided Graph的全部内容,更多相关886.内容请搜索靠谱客的其他文章。
发表评论 取消回复