leetcode 785. 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 AandBsuch that every edge in the graph has one node inAand 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 nodesiandjexists. Each node is an integer between0and graph.length - 1. There are no self edges or parallel edges:graph[i]does not containi, 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.

leetcode has identified us that this is a DFS search question, so let's interpret the next question.
Give us an undirected graph with n nodes, if this undirected graph can be divided into two subgraphs, so that graphboth endpoints of the original undirected graph can be divided into these two subgraphs , if not, return false.
Still use the dyeing method,

• -1 no color
• 1 for a color
• 0 represents another color
  because it only needs to ensure that the adjacent endpoints have different colors, so when DFS is a fixed point, it is used for its adjacent nodes 1 - colorto continue DFS
  starting from the first vertex, if there is already a color, just return.

class Solution {
    public boolean isBipartite(int[][] graph) {
        int n = graph.length;
        int[] colors = new int[n];
        Arrays.fill(colors, -1);            

        for (int i = 0; i < n; i++) {             
            if (colors[i] == -1 && !validColor(graph, colors, 0, i)) {
                return false;
            }
        }
        return true;
    }

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