恢复时间最短的路径

Question

The problem can be described in the following way:

A network of nodes has crashed, and each connection (edge) has a certain recovery time until it's back online and the two nodes are connected again. Our goal is to find the path between nodes 1 to n that is up and running the earliest, and return the longest recovery time on that path.

The network can be represented as a graph with undirected edges.

We have three arrays:

1. First one contains the origin vertices
2. Second one contains the destination vertices
3. Third one contains the recovery time of each connection (edge)

Example:

{1,2,2,3}, {2,3,4,4}, {1,5,10,2}

where the recovery time of the connection between nodes 1 and 2 is 1, etc..

The optimal path from 1 to n = 4 is 1-2-3-4, since the longest recovery time on this path is 5, in comparison to the path 1-2-4, where the longest recovery time is 10.

The important thing here is to notice, that only the longest recovery time on each path is what matters, ie the "length" of the path is not the sum of the waiting periods, but the length of the longest time one has to wait for the connection between two nodes to recover. Each recovery time is calculated from t = 0, so the recovery times are independent, and the order does not matter.

So what we have to do here is to find the path that has the minimum recovery time out of the maximum recovery times on each path, and return that time.

I have approached this problem using both Dijkstra's and Bellman-Ford -algorithm, but can't really wrap my head around on how to modify the algorithms to get the desired outcome. There can be at most 10^5 connections.

Answer 1

This is easy using DSU ( https://en.wikipedia.org/wiki/Disjoint-set_data_structure ):

1. Sort all edges by weight, increasing
2. Loop throught edges, if nodes u and v are in different disjoint sets, merge them into one disjoint set
3. If after merge nodes 1 and N are in same set, asnwer is weight of current edge and we can break out of loop.

Complexity: O(E log E + V log V)

Answer 2

DSU is the most beautiful solution, as described by Photon.

Another possible solution uses binary-search + dfs/bfs/Dijkstra/Bellman-Ford/

This algorithm will run DFS/BFS at most log( max possible edge cost ).

The algorithm would work as follows:

lo = 0, hi = largest cost from any edge from a graph
mid = dummy_value

while ( lo < hi ):
    mid = (lo + hi) / 2
    check if there is a path from source to destination using only edges with cost <= mid
    if there is a path:
        hi = mid
    else:
        lo = mid + 1

return mid

The solution using DSU has a better runtime complexity, but this introduces the idea of doing binary search on the answer which is a classical idea in problem solving. In some problems, doing DSU is not a possibility.