OpenSoure_Repos/TheAlgorithms-C-Plus-Plus
1
0
Fork 0
mirror of https://hub.njuu.cf/TheAlgorithms/C-Plus-Plus.git synced 2023-10-11 13:05:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix: linter for kosaraju (#1035)

Browse Source 
* fix: linter for kosaraju

* update doxygen parameters
This commit is contained in:
Filip Hlasek 2020-08-16 21:43:33 -07:00 committed by GitHub
parent 91ce393c45
commit 36f1d3327b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 47 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

87
graph/kosaraju.cpp
View File

@ -4,77 +4,84 @@
#include <iostream>
#include <vector>
#include <stack>
using namespace std;
/**
* Iterative function/method to print graph:
* @param a[] : array of vectors (2D)
* @param V : vertices
* @param a adjacency list representation of the graph
* @param V number of vertices
* @return void
**/
void print(vector<int> a[], int V) {
void print(const std::vector< std::vector<int> > &a, int V) {
for (int i = 0; i < V; i++) {
if (!a[i].empty())
cout << "i=" << i << "-->";
for (int j = 0; j < a[i].size(); j++) cout << a[i][j] << " ";
if (!a[i].empty())
cout << endl;
if (!a[i].empty()) {
std::cout << "i=" << i << "-->";
}
for (int j : a[i]) {
std::cout << j << " ";
}
if (!a[i].empty()) {
std::cout << std::endl;
}
}
}
/**
* //Recursive function/method to push vertices into stack passed as parameter:
* @param v : vertices
* @param &st : stack passed by reference
* @param vis[] : array to keep track of visited nodes (boolean type)
* @param adj[] : array of vectors to represent graph
* @param v vertices
* @param st stack passed by reference
* @param vis array to keep track of visited nodes (boolean type)
* @param adj adjacency list representation of the graph
* @return void
**/
void push_vertex(int v, stack<int> &st, bool vis[], vector<int> adj[]) {
vis[v] = true;
void push_vertex(int v, std::stack<int> *st, std::vector<bool> *vis, const std::vector< std::vector<int> > &adj) {
(*vis)[v] = true;
for (auto i = adj[v].begin(); i != adj[v].end(); i++) {
if (vis[*i] == false)
if ((*vis)[*i] == false) {
push_vertex(*i, st, vis, adj);
}
}
st.push(v);
st->push(v);
}
/**
* //Recursive function/method to implement depth first traversal(dfs):
* @param v : vertices
* @param vis[] : array to keep track of visited nodes (boolean type)
* @param grev[] : graph with reversed edges
* @param v vertices
* @param vis array to keep track of visited nodes (boolean type)
* @param grev graph with reversed edges
* @return void
**/
void dfs(int v, bool vis[], vector<int> grev[]) {
vis[v] = true;
void dfs(int v, std::vector<bool> *vis, const std::vector< std::vector<int> > &grev) {
(*vis)[v] = true;
// cout<<v<<" ";
for (auto i = grev[v].begin(); i != grev[v].end(); i++) {
if (vis[*i] == false)
if ((*vis)[*i] == false) {
dfs(*i, vis, grev);
}
}
}
// function/method to implement Kosaraju's Algorithm:
/**
* Info about the method
* @param V : vertices in graph
* @param adj[] : array of vectors that represent a graph (adjacency list/array)
* @param V vertices in graph
* @param adj array of vectors that represent a graph (adjacency list/array)
* @return int ( 0, 1, 2..and so on, only unsigned values as either there can be
no SCCs i.e. none(0) or there will be x no. of SCCs (x>0)) i.e. it returns the
count of (number of) strongly connected components (SCCs) in the graph.
(variable 'count_scc' within function)
**/
int kosaraju(int V, vector<int> adj[]) {
bool vis[V] = {};
stack<int> st;
int kosaraju(int V, const std::vector< std::vector<int> > &adj) {
std::vector<bool> vis(V, false);
std::stack<int> st;
for (int v = 0; v < V; v++) {
if (vis[v] == false)
push_vertex(v, st, vis, adj);
if (vis[v] == false) {
push_vertex(v, &st, &vis, adj);
}
}
// making new graph (grev) with reverse edges as in adj[]:
vector<int> grev[V];
std::vector< std::vector<int> > grev(V);
for (int i = 0; i < V + 1; i++) {
for (auto j = adj[i].begin(); j != adj[i].end(); j++) {
grev[*j].push_back(i);
@ -89,7 +96,7 @@ int kosaraju(int V, vector<int> adj[]) {
int t = st.top();
st.pop();
if (vis[t] == false) {
dfs(t, vis, grev);
dfs(t, &vis, grev);
count_scc++;
}
}
@ -101,21 +108,21 @@ int kosaraju(int V, vector<int> adj[]) {
// All critical/corner cases have been taken care of.
// Input your required values: (not hardcoded)
int main() {
int t;
cin >> t;
int t = 0;
std::cin >> t;
while (t--) {
int a, b; // a->number of nodes, b->directed edges.
cin >> a >> b;
int m, n;
vector<int> adj[a + 1];
int a = 0, b = 0; // a->number of nodes, b->directed edges.
std::cin >> a >> b;
int m = 0, n = 0;
std::vector< std::vector<int> > adj(a + 1);
for (int i = 0; i < b; i++) // take total b inputs of 2 vertices each
// required to form an edge.
{
cin >> m >> n; // take input m,n denoting edge from m->n.
std::cin >> m >> n; // take input m,n denoting edge from m->n.
adj[m].push_back(n);
}
// pass number of nodes and adjacency array as parameters to function:
cout << kosaraju(a, adj) << endl;
std::cout << kosaraju(a, adj) << std::endl;
}
return 0;
}