From 765ea70300fe644003b02e85327171e3081341ef Mon Sep 17 00:00:00 2001 From: anirudh chugh Date: Sun, 22 Oct 2017 00:10:15 +0530 Subject: [PATCH] added Tarjan's algorithm for finding articulation points in graph --- .DS_Store | Bin 0 -> 6148 bytes data_structures/.DS_Store | Bin 0 -> 6148 bytes data_structures/Graphs/tarjans.java | 171 ++++++++++++++++++++++++++++ 3 files changed, 171 insertions(+) create mode 100644 .DS_Store create mode 100644 data_structures/.DS_Store create mode 100644 data_structures/Graphs/tarjans.java diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..f1333da1cc548422af09aa8dd4d86f9de31407da GIT binary patch literal 6148 zcmeHK&2G~`5T0$*)~1yj1QJE!V2J}9BGf7^J#aB;dO!lTsv~;fC)lyo7#X{AoJ1&! z6b@W@0N_f2=YWUcJrHO3W_OFyBnWXq2<=F--|pm?#l>xLUdWg@bmjHPpE zW(d!-PRX3MaGa1iBFd?AC&^ktGUaUyh5^ICzs3MRyGzufn2xDUW6y6EV1{1{x1iU* zOF@rlnRY0nlzPe=kv!5*{m-b66H%)al1~M+NgZHLU94K5&5>s!T3q_G=%C*@4idTc zx8OL5JH`6?7cn%gA8lo;%T zoxK0>Nks{~WTl+fcnY7<`3=E6FHe&!J%T4^xj=P#j&1Yl88)y*4(($jGCD%bHnyg8 zq+aExn<`!+a=a84X%AaCvuwoI316EIXqRqd-Fv_rSRp){T^8EOSfN?up)`E_qLy4^ zqDY8KY}|hV{u#WBndLO@i9jQ&5Ws`AY{)PS7zPXj6AbV{;XoN(jU$C@V!ONo082b( zL7zVw7#)qS#*sqIK!gefs!*Y?7(#`^?r1+(<4B8Q-BwU52 zH4GRA&N48shGjngcYl5VKO1C5h5^ICf5m_()xCNRe@UOMQ-6-nS_k?B%EEplg)#(< iK8|IFkK#3`6wEo?0lFGT3Sohm4*^MoX$%8@m4P3%E7-RH literal 0 HcmV?d00001 diff --git a/data_structures/.DS_Store b/data_structures/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..021c0e72f74e00ccf62cbee1407c048ef0fbe632 GIT binary patch literal 6148 zcmeHK!EVz)5S?w4)Bz!KKx&V^AaTecQ7AniBrCLnN+5w;!2wWfHx{u7b`(2=5`ui; zBj5v&_!Pc?58(sg&Fq5g8mfKT9TQ@*M3Pvqg6yRR*c< zvt*_1j^+9cFU!>gFA{0X8zY!%yT-gnG5XCbTPQQ%pJTQpbB<3I)9Y$}^{vKzNOO#U z{oDxT(|)RaS|8a1I;9siF3+pXZPF3)NA+H1US%c%t*xg5W(hbK*K>GwR8|42z&})g z_Xiiw=ou_D%GQBGt^mLWn#EA(bC6?PgPy@cBi_K24h8B^Wv&=Xhojv!JkMaEQHPT< zmk(t!D|16pk{$iKLMP>Ew53(RDo|BmQ$Ke2{6F~f{l6MypR58_f&WSY)!6sMtjkIY1 literal 0 HcmV?d00001 diff --git a/data_structures/Graphs/tarjans.java b/data_structures/Graphs/tarjans.java new file mode 100644 index 000000000000..a9b6d2de034f --- /dev/null +++ b/data_structures/Graphs/tarjans.java @@ -0,0 +1,171 @@ +// A Java program to find articulation points in an undirected graph +import java.io.*; +import java.util.*; +import java.util.LinkedList; + +public class Graph { + + // This class represents an undirected graph using adjacency list + // representation + + private int V; // No. of vertices + + // Array of lists for Adjacency List Representation + private LinkedList adj[]; + int time = 0; + static final int NIL = -1; + + // Constructor + Graph(int v) { + V = v; + adj = new LinkedList[v]; + for (int i = 0; i < v; ++i) + adj[i] = new LinkedList(); + } + + // Function to add an edge into the graph + void addEdge(int v, int w) { + adj[v].add(w); // Add w to v's list. + adj[w].add(v); // Add v to w's list + } + + // A recursive function that find articulation points using DFS + // u --> The vertex to be visited next + // visited[] --> keeps tract of visited vertices + // disc[] --> Stores discovery times of visited vertices + // parent[] --> Stores parent vertices in DFS tree + // ap[] --> Store articulation points + void APUtil(int u, boolean visited[], int disc[], int low[], int parent[], boolean ap[]) { + + // Count of children in DFS Tree + int children = 0; + + // Mark the current node as visited + visited[u] = true; + + // Initialize discovery time and low value + disc[u] = low[u] = ++time; + + // Go through all vertices aadjacent to this + Iterator i = adj[u].iterator(); + while (i.hasNext()) { + int v = i.next(); // v is current adjacent of u + + // If v is not visited yet, then make it a child of u + // in DFS tree and recur for it + if (!visited[v]) { + children++; + parent[v] = u; + APUtil(v, visited, disc, low, parent, ap); + + // Check if the subtree rooted with v has a connection to + // one of the ancestors of u + low[u] = Math.min(low[u], low[v]); + + // u is an articulation point in following cases + + // (1) u is root of DFS tree and has two or more chilren. + if (parent[u] == NIL && children > 1) + ap[u] = true; + + // (2) If u is not root and low value of one of its child + // is more than discovery value of u. + if (parent[u] != NIL && low[v] >= disc[u]) + ap[u] = true; + } + + // Update low value of u for parent function calls. + else if (v != parent[u]) + low[u] = Math.min(low[u], disc[v]); + } + } + + void DFS(int u, boolean visited[], int disc[], int low[], int parent[], boolean ap[]) { + int children = 0; + visited[u] = true; + disc[u] = low[u] = ++time; + Iterator i = adj[u].iterator(); + while (i.hasNext()) { + int v = i.next(); + if (!visited[v]) { + children++; + parent[v] = u; + DFS(v, visited, disc, low, parent, ap) ; + low[u] = Math.min(low[u], low[v]) ; + if (parent[u] == NIL && children >= 2) { + ap[u] = true ; + } + if (parent[u] != NIL && low[v] >= disc[u]) { + ap[u] = true ; + } + + } else if (v != parent[u]) { + low[u] = Math.min(low[u], disc[v]); + } + } + + } + + // The function to do DFS traversal. It uses recursive function APUtil() + void AP() { + // Mark all the vertices as not visited + boolean visited[] = new boolean[V]; + int disc[] = new int[V]; + int low[] = new int[V]; + int parent[] = new int[V]; + boolean ap[] = new boolean[V]; // To store articulation points + + // Initialize parent and visited, and ap(articulation point) + // arrays + for (int i = 0; i < V; i++) { + parent[i] = NIL; + visited[i] = false; + ap[i] = false; + } + + // Call the recursive helper function to find articulation + // points in DFS tree rooted with vertex 'i' + for (int i = 0; i < V; i++) + if (visited[i] == false) + APUtil(i, visited, disc, low, parent, ap); + + // Now ap[] contains articulation points, print them + for (int i = 0; i < V; i++) + if (ap[i] == true) + System.out.print(i + " "); + } + + // Driver method + public static void main(String args[]) { + // Create graphs given in above diagrams + System.out.println("Articulation points in first graph "); + Graph g1 = new Graph(5); + g1.addEdge(1, 0); + g1.addEdge(0, 2); + g1.addEdge(2, 1); + g1.addEdge(0, 3); + g1.addEdge(3, 4); + g1.AP(); + System.out.println(); + + System.out.println("Articulation points in Second graph"); + Graph g2 = new Graph(4); + g2.addEdge(0, 1); + g2.addEdge(1, 2); + g2.addEdge(2, 3); + g2.AP(); + System.out.println(); + + System.out.println("Articulation points in Third graph "); + Graph g3 = new Graph(7); + g3.addEdge(0, 1); + g3.addEdge(1, 2); + g3.addEdge(2, 0); + g3.addEdge(1, 3); + g3.addEdge(1, 4); + g3.addEdge(1, 6); + g3.addEdge(3, 5); + g3.addEdge(4, 5); + g3.AP(); + } +}