# Maximize shortest path between given vertices by adding a single edge

• Difficulty Level : Hard
• Last Updated : 10 Nov, 2021

Given an undirected graph of N nodes and M vertices. You are also given a K edges as selected[]. The task to maximize the shortest path length between node 1 to node N by adding single edges between any two vertices from the given selected edges.
Note: You may add an edge between any two selected vertices who have already an edge between them.

Input: N = 5, M = 4, K = 2, selected[] = {2, 4}
Below is the given graph:

Output:
Explanation:
Before adding an edge between 2 and 4, the Shortest Path becomes: 1â€“>2â€“>3â€“>4â€“>5.
After adding an edge between 2 and 4, the Shortest Path becomes 1â€“>2â€“>4â€“>5. Below is the graph after adding edges. denoted by the dashed line.

Input: N = 5 M = 5 K = 3 selected[] = {1, 3, 5}
Below is the given graph:

Output:
Explanation:
We can add an edge between 3 and 5 as they have already an edge between them. so, the shortest path becomes 1â€“>2â€“>3â€“>5. Below is the graph after adding edges. denoted by the dashed line.

Approach: The idea is to use Breadth-First Search to find the distance from vertices 1 and N to each selected vertex. For selected vertex i, let xi denote the distance to node 1, and yi denote the distance to node N. Below are the steps:

1. Maintain a 2D matrix(say dist[2][]) having 2 rows and N columns.
2. In the first row, Maintain the shortest distance between node 1 and other vertices in the graph using BFS Traversal.
3. In the second row, Maintain the shortest distance between node N and the other vertices of the graph using BFS Traversal.
4. Now, choose two selected vertices a and b from selected[] to minimize the value of min(xa + yb, ya + xb). For this do the following:
• Create a vector of pairs and store the value of (xi – yi) with their respective selected node.
• Sort the above vector of pairs.
• Initialize best to 0 and max to -INF.
• Now traverse the above vector of pairs and for each selected node(say a) update the value of best to maximum of (best, max + dist[1][a]) and update max to maximum of (max, dist[0][a]).
5. After the above operations the maximum of (dist[0][N-1] and best + 1) given the minimum shortest path.

Below is the implementation of the above approach:

## C++

 // C++ program for the above approach#include using namespace std;const int INF = 1e9 + 7;int N, M; // To store graph as adjacency listvector edges[200005]; // To store the shortest pathint dist[2][200000]; // Function that performs BFS Traversalvoid bfs(int* dist, int s){    int q[200000];     // Fill initially each distance as INF    fill(dist, dist + N, INF);    int qh = 0, qt = 0;    q[qh++] = s;    dist[s] = 0;     // Perform BFS    while (qt < qh) {         int x = q[qt++];         // Traverse the current edges        for (int y : edges[x]) {            if (dist[y] == INF) {                 // Update the distance                dist[y] = dist[x] + 1;                 // Insert in queue                q[qh++] = y;            }        }    }} // Function that maximizes the shortest// path between source and destination// vertex by adding a single edge between// given selected nodesvoid shortestPathCost(int selected[], int K){    vector > data;     // To update the shortest distance    // between node 1 to other vertices    bfs(dist[0], 0);     // To update the shortest distance    // between node N to other vertices    bfs(dist[1], N - 1);     for (int i = 0; i < K; i++) {         // Store the values x[i] - y[i]        data.emplace_back(dist[0][selected[i]]                              - dist[1][selected[i]],                          selected[i]);    }     // Sort all the vectors of pairs    sort(data.begin(), data.end());    int best = 0;    int MAX = -INF;     // Traverse data[]    for (auto it : data) {        int a = it.second;        best = max(best,                   MAX + dist[1][a]);         // Maximize x[a] - y[b]        MAX= max(MAX, dist[0][a]);    }     // Print minimum cost    printf("%d\n", min(dist[0][N - 1], best + 1));} // Driver Codeint main(){    // Given nodes and edges    N = 5, M = 4;    int K = 2;    int selected[] = { 1, 3 };     // Sort the selected nodes    sort(selected, selected + K);     // Given edges    edges[0].push_back(1);    edges[1].push_back(0);    edges[1].push_back(2);    edges[2].push_back(1);    edges[2].push_back(3);    edges[3].push_back(2);    edges[3].push_back(4);    edges[4].push_back(3);     // Function Call    shortestPathCost(selected, K);    return 0;}

## Python3

 # Python3 program for the above approach # Function that performs BFS Traversaldef bfs(x, s):    global edges, dist    q = [0 for i in range(200000)]     # Fill initially each distance as INF    # fill(dist, dist + N, INF)    qh, qt = 0, 0    q[qh] = s    qh += 1    dist[x][s] = 0     # Perform BFS    while (qt < qh):        xx = q[qt]        qt += 1         # Traverse the current edges        for y in edges[xx]:            if (dist[x][y] == 10**18):                 # Update the distance                dist[x][y] = dist[x][xx] + 1                 # Insert in queue                q[qh] = y                qh += 1 # Function that maximizes the shortest# path between source and destination# vertex by adding a single edge between# given selected nodesdef shortestPathCost(selected, K):    global dist, edges    data = []     # To update the shortest distance    # between node 1 to other vertices    bfs(0, 0)     # To update the shortest distance    # between node N to other vertices    bfs(1, N - 1)    for i in range(K):         # Store the values x[i] - y[i]        data.append([dist[0][selected[i]]- dist[1][selected[i]], selected[i]])     # Sort all the vectors of pairs    data = sorted(data)    best = 0    MAX = -10**18     # Traverse data[]    for it in data:        a = it[1]        best = max(best,MAX + dist[1][a])         # Maximize x[a] - y[b]        MAX= max(MAX, dist[0][a])     # Print minimum cost    print(min(dist[0][N - 1], best + 1)) # Driver Codeif __name__ == '__main__':     # Given nodes and edges    edges = [[] for i in range(5)]    dist = [[10**18 for i in range(1000005)] for i in range(2)]    N,M = 5, 4    K = 2    selected = [1, 3]     # Sort the selected nodes    selected = sorted(selected)     # Given edges    edges[0].append(1)    edges[1].append(0)    edges[1].append(2)    edges[2].append(1)    edges[2].append(3)    edges[3].append(2)    edges[3].append(4)    edges[4].append(3)     # Function Call    shortestPathCost(selected, K)     # This code is contributed by mohit kumar 29

## Javascript



Output:

3

Time Complexity: O(N*log N + M)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up