Critical Connections in a Network in C++

Suppose there are n servers. And these are numbered from 0 to n-1 connected by an undirected server-to-server connections forming a network where connections[i] = [a,b] represents a connection between servers a and b. All servers are connected directly or through some other servers. Now, a critical connection is a connection that, if that is removed, it will make some server unable to reach some other server. We have to find all critical connections.

So, if the input is like n = 4 and connection = [[0,1],[1,2],[2,0],[1,3]],

then the output will be [[1,3]]

To solve this, we will follow these steps −

• Define one set

• Define an array disc

• Define an array low

• Define one 2D array ret

• Define a function dfs(), this will take node, par, one 2D array graph,

• if node is in of visited, then −

  • return

• insert node into visited

• disc[node] := time

• low[node] := time

• (increase time by 1)

• for all elements x in graph[node]

  • if x is same as par, then −

    • Ignore following part, skip to the next iteration

  • if x is not in visited, then −

    • dfs(x, node, graph)

    • low[node] := minimum of low[node] and low[x]

    • if disc[node] < low[x], then −

      • insert { node, x } at the end of ret

  • Otherwise

    • low[node] := minimum of low[node] and disc[x]

• From the main method, do the following −

  • set size of disc as n + 1

  • set size of low as n + 1

  • time := 0

  • Define an array of lists of size graph n + 1

  • for initialize i := 0, when i < size of v, update (increase i by 1), do −

    • u := v[i, 0]

    • w := v[i, 1]

    • insert w at the end of graph[u]

    • insert u at the end of graph[w]

  • dfs(0, -1, graph)

  • return ret

Let us see the following implementation to get better understanding −

Example

 Live Demo

#include <bits/stdc++.h>
using namespace std;
void print_vector(vector<vector<auto> > v){
   cout << "[";
   for(int i = 0; i<v.size(); i++){
      cout << "[";
      for(int j = 0; j <v[i].size(); j++){
         cout << v[i][j] << ", ";
      }
      cout << "],";
   }
   cout << "]"<<endl;
}
class Solution {
   public:
   set<int> visited;
   vector<int> disc;
   vector<int> low;
   int time;
   vector<vector<int> > ret;
   void dfs(int node, int par, vector<int> graph[]) {
      if (visited.count(node))
      return;
      visited.insert(node);
      disc[node] = low[node] = time;
      time++;
      for (int x : graph[node]) {
         if (x == par)
         continue;
         if (!visited.count(x)) {
            dfs(x, node, graph);
            low[node] = min(low[node], low[x]);
            if (disc[node] < low[x]) {
               ret.push_back({ node, x });
            }
         } else{
            low[node] = min(low[node], disc[x]);
         }
      }
   }
   vector<vector<int> > criticalConnections(int n, vector<vector<int> >& v) {
      disc.resize(n + 1);
      low.resize(n + 1);
      time = 0;
      vector<int> graph[n + 1];
      for (int i = 0; i < v.size(); i++) {
         int u = v[i][0];
         int w = v[i][1];
         graph[u].push_back(w);
         graph[w].push_back(u);
      }
      dfs(0, -1, graph);
      return ret;
   }
};
main(){
   Solution ob;
   vector<vector<int>> v = {{0,1},{1,2},{2,0},{1,3}};
   print_vector(ob.criticalConnections(4,v));
}

Input

4, {{0,1},{1,2},{2,0},{1,3}}

Output

[[1, 3, ],]