forked from burakbayramli/books
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathCycle.java
164 lines (146 loc) · 4.62 KB
/
Cycle.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
/*************************************************************************
* Compilation: javac Cycle.java
* Dependencies: Graph.java Stack.java
*
* Identifies a cycle.
* Runs in O(E + V) time.
*
* % java Cycle tinyG.txt
* 3 4 5 3
*
* % java Cycle mediumG.txt
* 15 0 225 15
*
* % java Cycle largeG.txt
* 996673 762 840164 4619 785187 194717 996673
*
*************************************************************************/
/**
* The <tt>Cycle</tt> class represents a data type for
* determining whether an undirected graph has a cycle.
* The <em>hasCycle</em> operation determines whether the graph has
* a cycle and, if so, the <em>cycle</em> operation returns one.
* <p>
* This implementation uses depth-first search.
* The constructor takes time proportional to <em>V</em> + <em>E</em>
* (in the worst case),
* where <em>V</em> is the number of vertices and <em>E</em> is the number of edges.
* Afterwards, the <em>hasCycle</em> operation takes constant time;
* the <em>cycle</em> operation takes time proportional
* to the length of the cycle.
* <p>
* For additional documentation, see <a href="/algs4/41graph">Section 4.1</a> of
* <i>Algorithms, 4th Edition</i> by Robert Sedgewick and Kevin Wayne.
*
* @author Robert Sedgewick
* @author Kevin Wayne
*/
public class Cycle {
private boolean[] marked;
private int[] edgeTo;
private Stack<Integer> cycle;
/**
* Determines whether the undirected graph <tt>G</tt> has a cycle and, if so,
* finds such a cycle.
* @param G the graph
*/
public Cycle(Graph G) {
if (hasSelfLoop(G)) return;
if (hasParallelEdges(G)) return;
marked = new boolean[G.V()];
edgeTo = new int[G.V()];
for (int v = 0; v < G.V(); v++)
if (!marked[v])
dfs(G, -1, v);
}
// does this graph have a self loop?
// side effect: initialize cycle to be self loop
private boolean hasSelfLoop(Graph G) {
for (int v = 0; v < G.V(); v++) {
for (int w : G.adj(v)) {
if (v == w) {
cycle = new Stack<Integer>();
cycle.push(v);
cycle.push(v);
return true;
}
}
}
return false;
}
// does this graph have two parallel edges?
// side effect: initialize cycle to be two parallel edges
private boolean hasParallelEdges(Graph G) {
marked = new boolean[G.V()];
for (int v = 0; v < G.V(); v++) {
// check for parallel edges incident to v
for (int w : G.adj(v)) {
if (marked[w]) {
cycle = new Stack<Integer>();
cycle.push(v);
cycle.push(w);
cycle.push(v);
return true;
}
marked[w] = true;
}
// reset so marked[v] = false for all v
for (int w : G.adj(v)) {
marked[w] = false;
}
}
return false;
}
/**
* Does the graph have a cycle?
* @return <tt>true</tt> if the graph has a cycle, <tt>false</tt> otherwise
*/
public boolean hasCycle() {
return cycle != null;
}
/**
* Returns a cycle if the graph has a cycle, and <tt>null</tt> otherwise.
* @return a cycle (as an iterable) if the graph has a cycle,
* and <tt>null</tt> otherwise
*/
public Iterable<Integer> cycle() {
return cycle;
}
private void dfs(Graph G, int u, int v) {
marked[v] = true;
for (int w : G.adj(v)) {
// short circuit if cycle already found
if (cycle != null) return;
if (!marked[w]) {
edgeTo[w] = v;
dfs(G, v, w);
}
// check for cycle (but disregard reverse of edge leading to v)
else if (w != u) {
cycle = new Stack<Integer>();
for (int x = v; x != w; x = edgeTo[x]) {
cycle.push(x);
}
cycle.push(w);
cycle.push(v);
}
}
}
/**
* Unit tests the <tt>Cycle</tt> data type.
*/
public static void main(String[] args) {
In in = new In(args[0]);
Graph G = new Graph(in);
Cycle finder = new Cycle(G);
if (finder.hasCycle()) {
for (int v : finder.cycle()) {
StdOut.print(v + " ");
}
StdOut.println();
}
else {
StdOut.println("Graph is acyclic");
}
}
}