力扣785 判断二分图

785. 判断二分图
给定一个无向图graph，当这个图为二分图时返回true。

如果我们能将一个图的节点集合分割成两个独立的子集A和B，

并使图中的每一条边的两个节点一个来自A集合，一个来自B集合，我们就将这个图称为二分图。

graph将会以邻接表方式给出，graph[i]表示图中与节点i相连的所有节点。

每个节点都是一个在0到graph.length-1之间的整数。这图中没有自环和平行边：

graph[i] 中不存在i，并且graph[i]中没有重复的值。


示例 1:
输入: [[1,3], [0,2], [1,3], [0,2]]
输出: true
解释:
无向图如下:
0----1
|    |
|    |
3----2
我们可以将节点分成两组: {0, 2} 和 {1, 3}。

示例 2:
输入: [[1,2,3], [0,2], [0,1,3], [0,2]]
输出: false
解释:
无向图如下:
0----1
| \  |
|  \ |
3----2
我们不能将节点分割成两个独立的子集。

二分图的解释：
对于图中的任意两个节点 uu 和 vv，如果它们之间有一条边直接相连，那么 uu 和 vv 必须属于不同的集合

我们可以采取染色法，对当前节点染上红色，然后其相邻节点染上绿色，

表示这些节点不能与起始节点属于同一个集合

然后将这些绿色的节点，所连接的其他节点染成红色

重复上述的步骤

直到所有节点都染色过

如果当v被染色，且与前面的节点相同，则说明不是二分图
下面分别是 深度优先遍历 广度优先遍历 以及并查集三种方法的python代码

from typing import *

"""
什么是二分图？：
对于图中的任意两个节点 uu 和 vv，如果它们之间有一条边直接相连，那么 uu 和 vv 必须属于不同的集合
"""


class Solution:
    def isBipartite(self, graph: List[List[int]]) -> bool:
        """
        如果给定的无向图连通，那么我们就可以任选一个节点开始，给它染成红色。

        随后我们对整个图进行遍历，将该节点直接相连的所有节点染成绿色，

        表示这些节点不能与起始节点属于同一个集合。

        我们再将这些绿色节点直接相连的所有节点染成红色，以此类推，直到无向图中的每个节点均被染色。


        我们任选一个节点开始，将其染成红色，并从该节点开始对整个无向图进行遍历；

        在遍历的过程中，如果我们通过节点 u 遍历到了节点 v（即 u 和 v 在图中有一条边直接相连），\
        那么会有两种情况：

        如果 v 未被染色，那么我们将其染成与 u 不同的颜色，并对 v 直接相连的节点进行遍历；

        如果 v 被染色，并且颜色与 u 相同，那么说明给定的无向图不是二分图。

        我们可以直接退出遍历并返回 \text{False}False 作为答案。

        当遍历结束时，说明给定的无向图是二分图，返回 \text{True}True 作为答案。

        :param graph:
        :return:
        """
        n = len(graph)
        UNCOLORED, RED, GREEN = 0, 1, 2
        color = [UNCOLORED] * n
        valid = True

        def dfs(node: int, c: int):
            # nonlocal关键字修饰变量后标识该变量是上一级函数中的局部变量
            nonlocal valid
            # 对其中节点染色
            color[node] = c
            # 对其余节点染上不同的色
            cNei = GREEN if c == RED else RED

            for neighbor in graph[node]:
                # 开始访问其相连的节点
                if color[neighbor] == UNCOLORED:
                    dfs(neighbor, cNei)
                    if not valid:
                        return
                elif color[neighbor] != cNei:
                    # 说明此时与上一个节点同色
                    # 返回
                    valid = False
                    return

        for i in range(n):
            # 题目中给定的无向图不一定保证连通，因此我们需要进行多次遍历，直到每一个节点都被染色
            if color[i] == UNCOLORED:
                dfs(i, RED)
                if not valid:
                    break
        return valid

    def isBipartiteBFS(self, graph: List[List[int]]) -> bool:
        from collections import deque
        n = len(graph)
        UNCOLORED, GREEN, RED = 0, 1, 2
        color = [UNCOLORED] * n

        for i in range(n):
            if color[i] == UNCOLORED:
                q = deque([i])
                color[i] = RED
                while q:
                    node = q.popleft()
                    cNei = GREEN if color[node] == RED else RED
                    for neighbour in graph[node]:
                        if color[neighbour] == UNCOLORED:
                            q.append(neighbour)
                            color[neighbour] = cNei
                        elif color[neighbour] != cNei:
                            return False
        return True


class UFS:
    def __init__(self, length):
        # p记录父节点
        # rank记录各个节点的深度
        self.p = [i for i in range(length)]
        self.rank = [0]*length

    def find(self, x):
        # 查找根节点
        # 递归查询
        if self.p[x] != x:
            self.p[x] = self.find(self.p[x])
        return self.p[x]

    def union(self, x, y):
        # 查找根节点
        rx, ry = self.find(x), self.find(y)
        if self.rank[rx] < self.rank[ry]:
            self.p[rx] = ry
        elif self.rank[rx] > self.rank[ry]:
            self.p[ry] = rx
        else:
            self.p[rx] = ry
            # 由于两个子树rank一致，此时连接到ry上，需要给ry的rank增加1
            self.rank[ry] += 1

    def isBipartiteUnion(self, graph: List[List[int]]) -> bool:
        """
        我们知道如果是二分图的话，

        那么图中每个顶点的所有邻接点都应该属于同一集合，且不与顶点处于同一集合。

        因此我们可以使用并查集来解决这个问题，我们遍历图中每个顶点，

        将当前顶点的所有邻接点进行合并，

        并判断这些邻接点中是否存在某一邻接点已经和当前顶点处于同一个集合中了，若是，则说明不是二分图。

        :param graph:
        :return:
        """
        ufs = UFS(len(graph))
        for i, g in enumerate(graph):
            root = ufs.find(i)
            # 若对面节点的根节点和当前节点根节点相同，返回False
            for j in range(len(g)):
                if root == ufs.find(g[j]):
                    return False

            # 否则就将节点合并
            for j in range(1, len(g)):
                ufs.union(g[j-1], g[j])
        return True