C++ प्रोग्राम यह जांचने के लिए कि कोई ग्राफ़ मजबूती से जुड़ा है या नहीं

निर्देशित ग्राफ़ में घटकों को दृढ़ता से जुड़ा हुआ कहा जाता है, जब एक घटक में प्रत्येक जोड़ी के बीच एक पथ होता है।

इस एल्गोरिथम को हल करने के लिए, सबसे पहले, प्रत्येक शीर्ष का अंतिम समय प्राप्त करने के लिए DFS एल्गोरिथ्म का उपयोग किया जाता है, अब ट्रांसपोज़्ड ग्राफ़ का अंतिम समय ज्ञात करें, फिर शीर्षों को टोपोलॉजिकल सॉर्ट द्वारा अवरोही क्रम में क्रमबद्ध किया जाता है।

इनपुट :ग्राफ़ का आसन्नता मैट्रिक्स।

आउटपुट :दिए गए ग्राफ़ में दृढ़ता से जुड़े हुए घटक निम्नलिखित हैं -

0 1 2
3
4

एल्गोरिदम

ट्रैवर्स (ग्राफ, स्टार्ट, विजिट किया गया)

इनपुट :वह ग्राफ़ जिसे ट्रेस किया जाएगा, आरंभिक शीर्ष और विज़िट किए गए फ़्लैग्स

नोड्स।

आउटपुट :डीएफएस तकनीक में प्रत्येक नोड से गुजरें और नोड्स प्रदर्शित करें।

Begin
   mark start as visited
   for all vertices v connected with start, do
      if v is not visited, then
         traverse(graph, v, visited)
   done
End

topoSort(u, विज़िट किया गया, स्टैक)

इनपुट - प्रारंभ नोड, विज़िट किए गए शीर्षों के लिए ध्वज, स्टैक।

आउटपुट - ग्राफ को छांटते समय स्टैक भरें।

Begin 
   mark u as visited 
   for all node v, connected with u, do 
      if v is not visited, then 
         topoSort(v, visited, stack) 
   done 
   push u into the stack 
End

getStrongConComponents(ग्राफ)

इनपुट -दिया गया ग्राफ।

आउटपुट - सभी मजबूती से जुड़े हुए घटक।

Begin
   initially all nodes are unvisited
   for all vertex i in the graph, do
      if i is not visited, then
         topoSort(i, vis, stack)
   done
   make all nodes unvisited again
   transGraph := transpose of given graph
   while stack is not empty, do
      pop node from stack and take into v
      if v is not visited, then
         traverse(transGraph, v, visited)
   done
End

उदाहरण कोड

#include <iostream>
#include <stack>
#define NODE 5
using namespace std;
int graph[NODE][NODE]= {
   {0, 0, 1, 1, 0},
   {1, 0, 0, 0, 0},
   {0, 1, 0, 0, 0},
   {0, 0, 0, 0, 1},
   {0, 0, 0, 0, 0}};
int transGraph[NODE][NODE];
void transpose() {       //transpose the graph and store to transGraph
   for(int i = 0; i<NODE; i++)
      for(int j = 0; j<NODE; j++)
         transGraph[i][j] = graph[j][i];
}
void traverse(int g[NODE][NODE], int u, bool visited[]) {
   visited[u] = true;    //mark v as visited
   cout << u << " ";
   for(int v = 0; v<NODE; v++) {
      if(g[u][v]) {
         if(!visited[v])
            traverse(g, v, visited);
      }
   }
}
void topoSort(int u, bool visited[], stack<int> &stk) {
   visited[u] = true;     //set as the node v is visited
   for(int v = 0; v<NODE; v++) {
      if(graph[u][v]) {     //for allvertices v adjacent to u
         if(!visited[v])
            topoSort(v, visited, stk);
      }
   }
   stk.push(u);     //push starting vertex into the stack
}
void getStrongConComponents() {
   stack<int> stk;
   bool vis[NODE];
   for(int i = 0; i<NODE; i++)
      vis[i] = false;    //initially all nodes are unvisited
   for(int i = 0; i<NODE; i++)
      if(!vis[i])     //when node is not visited
         topoSort(i, vis, stk);
   for(int i = 0; i<NODE; i++)
      vis[i] = false;    //make all nodes are unvisited for traversal
   transpose();       //make reversed graph
   while(!stk.empty()) {     //when stack contains element, process in topological order
      int v = stk.top(); stk.pop();
         if(!vis[v]) {
            traverse(transGraph, v, vis);
            cout << endl;
         }
   }
}
int main() {
   cout << "Following are strongly connected components in given graph: "<<endl;
   getStrongConComponents();
}

आउटपुट

Following are strongly connected components in given graph:
0 1 2
3
4