剑指 Offer II 106. 二分图（中等 图 bfs dfs）

剑指 Offer II 106. 二分图

存在一个 无向图 ，图中有 n 个节点。其中每个节点都有一个介于 0 到 n - 1 之间的唯一编号。

给定一个二维数组 graph ，表示图，其中 graph[u] 是一个节点数组，由节点 u 的邻接节点组成。形式上，对于 graph[u] 中的每个 v ，都存在一条位于节点 u 和节点 v 之间的无向边。该无向图同时具有以下属性：

不存在自环（graph[u] 不包含 u）。
不存在平行边（graph[u] 不包含重复值）。
如果 v 在 graph[u] 内，那么 u 也应该在 graph[v] 内（该图是无向图）
这个图可能不是连通图，也就是说两个节点 u 和 v 之间可能不存在一条连通彼此的路径。
二分图 定义：如果能将一个图的节点集合分割成两个独立的子集 A 和 B ，并使图中的每一条边的两个节点一个来自 A 集合，一个来自 B 集合，就将这个图称为 二分图 。

如果图是二分图，返回 true ；否则，返回 false 。

示例 1：

输入：graph = [[1,2,3],[0,2],[0,1,3],[0,2]]
输出：false
解释：不能将节点分割成两个独立的子集，以使每条边都连通一个子集中的一个节点与另一个子集中的一个节点。
示例 2：

输入：graph = [[1,3],[0,2],[1,3],[0,2]]
输出：true
解释：可以将节点分成两组: {0, 2} 和 {1, 3} 。

提示：

graph.length == n
1 <= n <= 100
0 <= graph[u].length < n
0 <= graph[u][i] <= n - 1
graph[u] 不会包含 u
graph[u] 的所有值 互不相同
如果 graph[u] 包含 v，那么 graph[v] 也会包含 u

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/vEAB3K
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

分析

方法一：广度优先搜索
本题的思路是，对于一个节点如果它在子集A中，那么它的所有邻接点都在B中，我们对在A或B子集中的节点进行标记，方便起见，在A中的标记为 0 ，在B中的标记为 1 （反过来也可以），如果某一个节点已经被标记为 0，那么如果在进行后续的标记时出现该节点被标记为 1 的情况，就说明不是二分图。
根据以上思路进行代码设计。利用广度优先搜索，先创建一个visited[]数组储存访问过的节点（因为是无向图所以数组为一维），初始化数组全为 -1，对每个节点进行遍历，未被标记的节点放入判断方法进行判断，判断方法是个广度优先搜索方法，利用队列对当前节点所有邻接点进行判断是否被标记以及是否与当前节点的标记冲突。
方法二：深度优先搜索
dfs 代码先判断有没有被标记，如果被标记了判断是否冲突，直接返回true 或 false，如果没有标记就进行标记进入下一个递归判断。

题解（Java）

方法一：广度优先搜索

class Solution {
    private int[] visited;

    public boolean isBipartite(int[][] graph) {
        int size = graph.length;
        visited = new int[size];
        Arrays.fill(visited, -1); // 初始化
        for (int i = 0; i < size; i++) {
            if (visited[i] == -1) {
                if (!judge(graph, i, 0)) {
                    return false;
                }
            }
        }
        return true;
    }
	// bfs
    private boolean judge(int[][] graph, int i, int j) {
        Queue<Integer> q = new LinkedList<>();
        q.offer(i);
        visited[i] = j;
        while (!q.isEmpty()) {
            int v = q.poll();
            for (int neighbor : graph[v]) {
                if (visited[neighbor] >= 0) { // 邻接点被标记过了，判断是否冲突
                    if (visited[neighbor] == visited[v]) {
                        return false; // 冲突返回false
                    }
                } else {
                    q.offer(neighbor);
                    visited[neighbor] = 1 - visited[v]; // 标记邻接点
                }
            }
        }
        return true;
    }
}

方法二：深度优先搜索

class Solution {
    private int[] visited;

    public boolean isBipartite(int[][] graph) {
        int size = graph.length;
        visited = new int[size];
        Arrays.fill(visited, -1);
        for (int i = 0; i < size; i++) {
            if (visited[i] == -1) {
                if (!judge(graph, i, 0)) {
                    return false;
                }
            }
        }
        return true;
    }

    private boolean judge(int[][] graph, int i, int j) {
        if (visited[i] >= 0) { //先判断有没有标记
            return visited[i] == j; //冲突返回false，不冲突返回true
        }
        visited[i] = j;
        for (int neighbor : graph[i]) {
            if (!judge(graph, neighbor, 1 - j)) {
                return false;
            }
        }
        return true;
    }
}