Is Graph Bipartite?

Given an undirected graph, return true if and only if it is bipartite.

Recall that a graph is bipartite if we can split it's set of nodes into two independent subsets A and B such that every edge in the graph has one node in A and another node in B.

The graph is given in the following form: graph[i] is a list of indexes j for which the edge between nodes i and j exists.  Each node is an integer between 0 and graph.length - 1.  There are no self edges or parallel edges: graph[i] does not contain i, and it doesn't contain any element twice.

Example 1:
Input: [[1,3], [0,2], [1,3], [0,2]]
Output: true
Explanation:
The graph looks like this:
0----1
|    |
|    |
3----2
We can divide the vertices into two groups: {0, 2} and {1, 3}.

Example 2:
Input: [[1,2,3], [0,2], [0,1,3], [0,2]]
Output: false
Explanation:
The graph looks like this:
0----1
| \  |
|  \ |
3----2
We cannot find a way to divide the set of nodes into two independent subsets.
分析：

Our goal is trying to use two colors to color the graph and see if there are any adjacent nodes having the same color.
Initialize a color[] array for each node. Here are three states for colors[] array:
0: Haven't been colored yet.
1: Blue.
-1: Red.
For each node,

1. If it hasn't been colored, use a color to color it. Then use the other color to color all its adjacent nodes (DFS).
2. If it has been colored, check if the current color is the same as the color that is going to be used to color it.

DFS

 class Solution {
     public boolean isBipartite(int[][] graph) {
         int n = graph.length;
         // 0 unvisited 1 red -1 blue
         int[] colors = new int[n];
         //This graph might be a disconnected graph. So check each unvisited node.
         for (int i = ; i < n; i++) {
             if (colors[i] == ) {
                 if (!validColor(graph, colors, , i)) {
                     return false;
                 }
             }
         }
         return true;
     }

     public boolean validColor(int[][] graph, int[] colors, int color, int node) {
         colors[node] = color;
         for (int next : graph[node]) {
             if (colors[next] ==  && !validColor(graph, colors, -color, next)) {
                 return false;
             } else if (colors[next] == colors[node]) {
                 return false;
             }
         }
         return true;
     }
 }

BFS

 class Solution {
     public boolean isBipartite(int[][] graph) {
         // 0: unvisited; 1: black; 2: white
         int[] status = new int[graph.length];
         // for loop is used to handle unconnected components in the graph
         for (int i = ; i < graph.length; i++) {
             if (status[i] == ) {
                 status[i] = ;
                 if (!bfs(i, status, graph)) {
                     return false;
                 };
             }
         }
         return true;
     }

     private boolean bfs(int i, int[] status, int[][] graph) {
         Queue<Integer> queue = new LinkedList<>();
         queue.offer(i);
         while (!queue.isEmpty()) {
             int current = queue.poll();
             for (int neighbor : graph[current]) {
                 if (status[neighbor] == ) {
                     status[neighbor] = (status[current] == ) ?  : ;
                     queue.offer(neighbor);
                 } else {
                     if (status[neighbor] == status[current]) return false;
                 }
             }
         }
         return true;
     }
 }