update ch4

AceCoooool · AceCoooool · commit 861a1bf40a23 · 2018-06-29T21:04:56.000+08:00
diff --git a/README.md b/README.md
@@ -64,9 +64,12 @@ Algorithms, 4th edition textbook code (using c++)
 
 ## ch4. Graphs
 
-|                             REF                             |                      PROGRAM                      |     DESCRIPTION / JAVADOC     |                             REF                             |                           PROGRAM                            |     DESCRIPTION / JAVADOC     |
-| :---------------------------------------------------------: | :-----------------------------------------------: | :---------------------------: | :---------------------------------------------------------: | :----------------------------------------------------------: | :---------------------------: |
-|   [-](https://algs4.cs.princeton.edu/41graph/index.php#-)   |            [Graph.h](ch4/head/Graph.h)            |       undirected graph        |   [-](https://algs4.cs.princeton.edu/41graph/index.php#-)   | [GraphGenerator.java](https://algs4.cs.princeton.edu/41graph/GraphGenerator.java.html) |    generate random graphs     |
-|   [-](https://algs4.cs.princeton.edu/41graph/index.php#-)   | [DepthFirstSearch.h](ch4/head/DepthFirstSearch.h) | depth-first search in a graph |   [-](https://algs4.cs.princeton.edu/41graph/index.php#-)   |       [NonrecursiveDFS.h](ch4/head/NonrecursiveDFS.h)        | DFS in a graph (nonrecursive) |
-| [4.1](https://algs4.cs.princeton.edu/41graph/index.php#4.1) |  [DepthFirstPaths.h](ch4/head/DepthFirstPaths.h)  |    paths in a graph (DFS)     | [4.2](https://algs4.cs.princeton.edu/41graph/index.php#4.2) |     [BreadthFirstPaths.h](ch4/head/BreadthFirstPaths.h)      |    paths in a graph (BFS)     |
+|                             REF                             |                      PROGRAM                      |      DESCRIPTION / JAVADOC      |                             REF                             |                           PROGRAM                            |     DESCRIPTION / JAVADOC     |
+| :---------------------------------------------------------: | :-----------------------------------------------: | :-----------------------------: | :---------------------------------------------------------: | :----------------------------------------------------------: | :---------------------------: |
+|   [-](https://algs4.cs.princeton.edu/41graph/index.php#-)   |            [Graph.h](ch4/head/Graph.h)            |        undirected graph         |   [-](https://algs4.cs.princeton.edu/41graph/index.php#-)   | [GraphGenerator.java](https://algs4.cs.princeton.edu/41graph/GraphGenerator.java.html) |    generate random graphs     |
+|   [-](https://algs4.cs.princeton.edu/41graph/index.php#-)   | [DepthFirstSearch.h](ch4/head/DepthFirstSearch.h) |  depth-first search in a graph  |   [-](https://algs4.cs.princeton.edu/41graph/index.php#-)   |       [NonrecursiveDFS.h](ch4/head/NonrecursiveDFS.h)        | DFS in a graph (nonrecursive) |
+| [4.1](https://algs4.cs.princeton.edu/41graph/index.php#4.1) |  [DepthFirstPaths.h](ch4/head/DepthFirstPaths.h)  |     paths in a graph (DFS)      | [4.2](https://algs4.cs.princeton.edu/41graph/index.php#4.2) |     [BreadthFirstPaths.h](ch4/head/BreadthFirstPaths.h)      |    paths in a graph (BFS)     |
+| [4.3](https://algs4.cs.princeton.edu/41graph/index.php#4.3) |               [CC.h](ch4/head/CC.h)               | connected components of a graph |   [-](https://algs4.cs.princeton.edu/41graph/index.php#-)   |             [Bipartite.h](ch4/head/Bipartite.h)              | bipartite or odd cycle (DFS)  |
+|   [-](https://algs4.cs.princeton.edu/41graph/index.php#-)   |       [BipartiteX.h](ch4/head/BipartiteX.h)       |  bipartite or odd cycle (BFS)   |   [-](https://algs4.cs.princeton.edu/41graph/index.php#-)   |                 [Cycle.h](ch4/head/Cycle.h)                  |       cycle in a graph        |
+|                                                             |                                                   |                                 |                                                             |                                                              |                               |
 
diff --git a/ch4/10_Cycle/CMakeLists.txt b/ch4/10_Cycle/CMakeLists.txt
@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 3.8)
+project(10_Cycle)
+
+set(CMAKE_CXX_STANDARD 14)
+
+set(SOURCE_FILES main.cpp ../head/Graph.h ../head/GraphGenerator.h ../head/DepthFirstSearch.h ../head/EulerianCycle.h)
+add_executable(10_Cycle ${SOURCE_FILES})
diff --git a/ch4/10_Cycle/main.cpp b/ch4/10_Cycle/main.cpp
@@ -0,0 +1,24 @@
+#include <iostream>
+#include "../head/Cycle.h"
+
+using namespace std;
+
+/**
+ * Unit tests the {@code Cycle} data type.
+ *
+ * @param args the command-line arguments
+ */
+int main() {
+    string filename = "/home/ace/AceDev/C++/algorithm/ch4/data/tinyG.txt";
+    Graph G(filename);
+    Cycle finder(G);
+    if (finder.hasCycle()) {
+        auto cyc = finder.getcycle();
+        while (!cyc.empty()) {
+            cout << cyc.top() << " ";
+            cyc.pop();
+        }
+        cout << endl;
+    } else
+        cout << "Graph is acyclic" << endl;
+}
diff --git a/ch4/7_CC/CMakeLists.txt b/ch4/7_CC/CMakeLists.txt
@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 3.8)
+project(7_CC)
+
+set(CMAKE_CXX_STANDARD 14)
+
+set(SOURCE_FILES main.cpp ../head/Graph.h ../head/GraphGenerator.h ../head/DepthFirstSearch.h)
+add_executable(7_CC ${SOURCE_FILES})
diff --git a/ch4/7_CC/main.cpp b/ch4/7_CC/main.cpp
@@ -0,0 +1,31 @@
+#include <iostream>
+#include <queue>
+#include "../head/CC.h"
+
+using namespace std;
+
+/**
+ * Unit tests the {@code BreadthFirstPaths} data type.
+ *
+ * @param args the command-line arguments
+ */
+int main() {
+    string filename = "/home/ace/AceDev/C++/algorithm/ch4/data/tinyG.txt";
+    Graph g(filename);
+    CC cc(g);
+    int m = cc.getcount();
+    cout << m << " components" << endl;
+    vector<queue<int>> components(m);
+    for (int v = 0; v < g.getV(); ++v) {
+        components[cc.getid(v)].push(v);
+    }
+    // print results
+    for (int i = 0; i < m; ++i) {
+        while (!components[i].empty()) {
+            auto v = components[i].front();
+            components[i].pop();
+            cout << v << " ";
+        }
+        cout << endl;
+    }
+}
diff --git a/ch4/8_Bipartite/CMakeLists.txt b/ch4/8_Bipartite/CMakeLists.txt
@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 3.8)
+project(8_Bipartite)
+
+set(CMAKE_CXX_STANDARD 14)
+
+set(SOURCE_FILES main.cpp ../head/Graph.h ../head/GraphGenerator.h ../head/DepthFirstSearch.h)
+add_executable(8_Bipartite ${SOURCE_FILES})
diff --git a/ch4/8_Bipartite/main.cpp b/ch4/8_Bipartite/main.cpp
@@ -0,0 +1,43 @@
+#include <iostream>
+#include <queue>
+#include "../head/GraphGenerator.h"
+#include "../head/Bipartite.h"
+
+using namespace std;
+
+/**
+ * Unit tests the {@code Bipartite} data type.
+ *
+ * @param args the command-line arguments
+ */
+int main() {
+    int V1 = 5;
+    int V2 = 8;
+    int E = 4;
+    int F = 6;
+    // create random bipartite graph with V1 vertices on left side,
+    // V2 vertices on right side, and E edges; then add F random edges
+    Graph G = GraphGenerator::bipartite(V1, V2, E);
+    uniform_int_distribution<> dis(0, V1 + V2 - 1);
+    for (int i = 0; i < F; ++i) {
+        int v = dis(g);
+        int w = dis(g);
+        G.addEdge(v, w);
+    }
+
+    cout << G << endl;
+    Bipartite b(G);
+    if (b.getisBipartite()) {
+        cout << "Graph is bipartite" << endl;
+        for (int v = 0; v < G.getV(); ++v) {
+            cout << v << " : " << b.getcolor(v) << endl;
+        }
+    } else {
+        cout << "Graph has an odd-length cycle: ";
+        auto odd = b.oddCycle();
+        while (!odd.empty()) {
+            cout << odd.top() << " ";
+            odd.pop();
+        }
+    }
+}
diff --git a/ch4/9_BipartiteX/CMakeLists.txt b/ch4/9_BipartiteX/CMakeLists.txt
@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 3.8)
+project(9_BipartiteX)
+
+set(CMAKE_CXX_STANDARD 14)
+
+set(SOURCE_FILES main.cpp ../head/Graph.h ../head/GraphGenerator.h ../head/DepthFirstSearch.h)
+add_executable(9_BipartiteX ${SOURCE_FILES})
diff --git a/ch4/9_BipartiteX/main.cpp b/ch4/9_BipartiteX/main.cpp
@@ -0,0 +1,43 @@
+#include <iostream>
+#include <queue>
+#include "../head/GraphGenerator.h"
+#include "../head/BipartiteX.h"
+
+using namespace std;
+
+/**
+ * Unit tests the {@code Bipartite} data type.
+ *
+ * @param args the command-line arguments
+ */
+int main() {
+    int V1 = 5;
+    int V2 = 8;
+    int E = 4;
+    int F = 6;
+    // create random bipartite graph with V1 vertices on left side,
+    // V2 vertices on right side, and E edges; then add F random edges
+    Graph G = GraphGenerator::bipartite(V1, V2, E);
+    uniform_int_distribution<> dis(0, V1 + V2 - 1);
+    for (int i = 0; i < F; ++i) {
+        int v = dis(g);
+        int w = dis(g);
+        G.addEdge(v, w);
+    }
+
+    cout << G << endl;
+    BipartiteX b(G);
+    if (b.getisBipartite()) {
+        cout << "Graph is bipartite" << endl;
+        for (int v = 0; v < G.getV(); ++v) {
+            cout << v << " : " << b.getcolor(v) << endl;
+        }
+    } else {
+        cout << "Graph has an odd-length cycle: ";
+        auto odd = b.oddCycle();
+        while (!odd.empty()) {
+            cout << odd.front() << " ";
+            odd.pop();
+        }
+    }
+}
diff --git a/ch4/CMakeLists.txt b/ch4/CMakeLists.txt
@@ -4,9 +4,14 @@ project(ch4)
 set(CMAKE_CXX_STANDARD 14)
 
 add_subdirectory(1_Graph)
+add_subdirectory(2_GraphGenerator)
 add_subdirectory(3_DepthFirstSearch)
 add_subdirectory(4_NonrecursiveDFS)
 add_subdirectory(5_DepthFirstPaths)
 add_subdirectory(6_BreadthFirstPaths)
+add_subdirectory(7_CC)
+add_subdirectory(8_Bipartite)
+add_subdirectory(9_BipartiteX)
+add_subdirectory(10_Cycle)
 
 add_subdirectory(temp)
diff --git a/ch4/head/Bipartite.h b/ch4/head/Bipartite.h
@@ -0,0 +1,127 @@
+#ifndef CH4_BIPARTITE_H
+#define CH4_BIPARTITE_H
+
+#include "../head/Graph.h"
+
+
+/**
+ *  The {@code Bipartite} class represents a data type for
+ *  determining whether an undirected graph is bipartite or whether
+ *  it has an odd-length cycle.
+ *  The <em>isBipartite</em> operation determines whether the graph is
+ *  bipartite. If so, the <em>color</em> operation determines a
+ *  bipartition; if not, the <em>oddCycle</em> operation determines a
+ *  cycle with an odd number of edges.
+ *  <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>isBipartite</em> and <em>color</em> operations
+ *  take constant time; the <em>oddCycle</em> operation takes time proportional
+ *  to the length of the cycle.
+ *  See {@link BipartiteX} for a nonrecursive version that uses breadth-first
+ *  search.
+ *  <p>
+ *  For additional documentation, see <a href="https://algs4.cs.princeton.edu/41graph">Section 4.1</a>
+ *  of <i>Algorithms, 4th Edition</i> by Robert Sedgewick and Kevin Wayne.
+ *
+ *  @author Robert Sedgewick
+ *  @author Kevin Wayne
+ */
+class Bipartite {
+public:
+    /**
+     * Determines whether an undirected graph is bipartite and finds either a
+     * bipartition or an odd-length cycle.
+     *
+     * @param  G the graph
+     */
+    Bipartite(Graph &G) : isBipartite(true), color(G.getV()), marked(G.getV()), edgeTo(G.getV()) {
+        for (int v = 0; v < G.getV(); v++) {
+            if (!marked[v]) {
+                dfs(G, v);
+            }
+        }
+    }
+
+    /**
+     * Returns true if the graph is bipartite.
+     *
+     * @return {@code true} if the graph is bipartite; {@code false} otherwise
+     */
+    bool getisBipartite() {
+        return isBipartite;
+    }
+
+    /**
+     * Returns the side of the bipartite that vertex {@code v} is on.
+     *
+     * @param  v the vertex
+     * @return the side of the bipartition that vertex {@code v} is on; two vertices
+     *         are in the same side of the bipartition if and only if they have the
+     *         same color
+     * @throws IllegalArgumentException unless {@code 0 <= v < V}
+     * @throws UnsupportedOperationException if this method is called when the graph
+     *         is not bipartite
+     */
+    bool getcolor(int v) {
+        validateVertex(v);
+        if (!isBipartite)
+            throw runtime_error("graph is not bipartite");
+        return color[v];
+    }
+
+    /**
+     * Returns an odd-length cycle if the graph is not bipartite, and
+     * {@code null} otherwise.
+     *
+     * @return an odd-length cycle if the graph is not bipartite
+     *         (and hence has an odd-length cycle), and {@code null}
+     *         otherwise
+     */
+    stack<int> oddCycle() {
+        return cycle;
+    }
+
+private:
+    // throw an IllegalArgumentException unless {@code 0 <= v < V}
+    void validateVertex(int v) {
+        int V = marked.size();
+        if (v < 0 || v >= V)
+            throw runtime_error("vertex " + to_string(v) + " is not between 0 and " + to_string(V - 1));
+    }
+
+    void dfs(Graph G, int v) {
+        marked[v] = true;
+        for (int w : G.getadj(v)) {
+            // short circuit if odd-length cycle found
+            if (!cycle.empty()) return;
+
+            // found uncolored vertex, so recur
+            if (!marked[w]) {
+                edgeTo[w] = v;
+                color[w] = !color[v];
+                dfs(G, w);
+            } // if v-w create an odd-length cycle, find it
+            else if (color[w] == color[v]) {
+                isBipartite = false;
+                cycle.push(w);  // don't need this unless you want to include start vertex twice
+                for (int x = v; x != w; x = edgeTo[x]) {
+                    cycle.push(x);
+                }
+                cycle.push(w);
+            }
+        }
+    }
+
+
+private:
+    bool isBipartite;     // is the graph bipartite?
+    vector<bool> color;   // color[v] gives vertices on one side of bipartition
+    vector<bool> marked;  // marked[v] = true iff v has been visited in DFS
+    vector<int> edgeTo;   // edgeTo[v] = last edge on path to v
+    stack<int> cycle;     // odd-length cycle
+};
+
+#endif //CH4_BIPARTITE_H
diff --git a/ch4/head/BipartiteX.h b/ch4/head/BipartiteX.h
diff --git a/ch4/head/CC.h b/ch4/head/CC.h
diff --git a/ch4/head/Cycle.h b/ch4/head/Cycle.h
diff --git a/ch4/head/EulerianCycle.h b/ch4/head/EulerianCycle.h
diff --git a/ch4/head/GraphGenerator.h b/ch4/head/GraphGenerator.h
