Maximize shortest path between given vertices by adding a single edge

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: 3
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: 3
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:



CPP

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
int N, M;
  
// To store graph as adjacency list
vector<int> edges[200005];
  
// To store the shortest path
int dist[2][200000];
  
// Function that performs BFS Traversal
void 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 nodes
void shortestPathCost(int selected[], int K)
{
    vector<pair<int, int> > 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 Code
int 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;
}

chevron_right


Output:

3


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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.