add a solution for 785

Author: fishercoder1534

src/main/java/com/fishercoder/solutions/_785.java

@@ -2,6 +2,7 @@
 
 import java.util.LinkedList;
 import java.util.Queue;
+import java.util.Stack;
 
 public class _785 {
     public static class Solution1 {
@@ -11,7 +12,7 @@ public static class Solution1 {
         public boolean isBipartite(int[][] graph) {
             int[] visited = new int[graph.length];
             //BFS
-            //0 means never encountered before, 1 means traversing in progress, 2 means traversing completed
+            //0 means never encountered before, 1 means we put this node into set A, 2 means we put this node into set B
             for (int i = 0; i < graph.length; i++) {
                 if (graph[i].length != 0 && visited[i] == 0) {
                     visited[i] = 1;
@@ -21,6 +22,7 @@ public boolean isBipartite(int[][] graph) {
                         int current = queue.poll();
                         for (int node : graph[current]) {
                             if (visited[node] == 0) {
+                                //if the current node is in set A (1), then we put its neighbor in set B (2), otherwise set A (1)
                                 visited[node] = (visited[current] == 1) ? 2 : 1;
                                 queue.offer(node);
                             } else {
@@ -35,4 +37,39 @@ public boolean isBipartite(int[][] graph) {
             return true;
         }
     }
+
+    public static class Solution2 {
+        /**
+         * credit: https://leetcode.com/problems/is-graph-bipartite/solution/
+         * <p>
+         * Let red indicate set A and blue indicate set B, if the graph is a bipartite,
+         * we should be able to greedily color this graph: for each node, if we color it red, then color all of its neighbors blue, etc.
+         */
+        public boolean isBipartite(int[][] graph) {
+            //0 means uncolored, 1 means red and 2 means blue
+            int[] colors = new int[graph.length];
+            for (int start = 0; start < graph.length; start++) {
+                if (colors[start] == 0) {
+                    Stack<Integer> stack = new Stack<>();
+                    stack.push(start);
+                    colors[start] = 1;//color it to be red
+
+                    while (!stack.isEmpty()) {
+                        Integer curr = stack.pop();
+                        for (int neighbor : graph[curr]) {
+                            if (colors[neighbor] == 0) {
+                                stack.push(neighbor);
+                                //if the current node is red (1), then we color it to be blue (2), otherwise red (1)
+                                colors[neighbor] = (colors[curr] == 1) ? 2 : 1;
+                            } else if (colors[neighbor] == colors[curr]) {
+                                //this means the two connected nodes have the same color, so this is not a bipartite
+                                return false;
+                            }
+                        }
+                    }
+                }
+            }
+            return true;
+        }
+    }
 }

src/test/java/com/fishercoder/_785Test.java

@@ -5,29 +5,34 @@
 import org.junit.BeforeClass;
 import org.junit.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 
 public class _785Test {
     private static _785.Solution1 solution1;
+    private static _785.Solution2 solution2;
     private static int[][] graph;
 
     @BeforeClass
     public static void setup() {
         solution1 = new _785.Solution1();
+        solution2 = new _785.Solution2();
         graph = new int[][]{};
     }
 
     @Test
     public void test1() {
         graph = CommonUtils.convertLeetCodeIrregularLengths2DArrayInputIntoJavaArray("[1,2,3],[0,2],[0,1,3],[0,2]");
         CommonUtils.print2DIntArray(graph);
-        assertEquals(false, solution1.isBipartite(graph));
+        assertFalse(solution1.isBipartite(graph));
+        assertFalse(solution2.isBipartite(graph));
     }
 
     @Test
     public void test2() {
         graph = CommonUtils.convertLeetCodeIrregularLengths2DArrayInputIntoJavaArray("[1,3],[0,2],[1,3],[0,2]");
         CommonUtils.print2DIntArray(graph);
-        assertEquals(true, solution1.isBipartite(graph));
+        assertTrue(solution1.isBipartite(graph));
+        assertTrue(solution2.isBipartite(graph));
     }
 }