当前位置：首页 > article >正文

【有啥问啥】二分图（Bipartite Graph）算法原理详解

article 2024/12/25 2:31:19

二分图

二分图（Bipartite Graph）算法原理详解

引言

二分图（Bipartite Graph），又称二部图，是图论中的一个重要概念。在实际应用中，二分图模型经常用于解决如匹配问题、覆盖问题和独立集问题等。本文将详细解析二分图的基本概念、性质、判定方法，以及求解最大匹配问题的匈牙利算法，并探讨其在实际中的应用。

传送门链接: 图的数据结构（Graph Data Structures）：深入探索与应用

1. 基本概念

1.1 定义

设 $G = (V, E)$ 是一个无向图，如果顶点集 $V$ 可以分割为两个互不相交的子集 $A$ 和 $B$ ，且图中的每条边 $(i, j)$ 所关联的两个顶点 $i$ 和 $j$ 分别属于这两个不同的顶点集（即 $\in A, j \in B$ ），则称图 $G$ 为一个二分图。

1.2 性质

无向图G为二分图的充分必要条件：
- G中至少包含两个顶点。
- G中所有回路的长度均为偶数。
二分图的匹配：
- 设 $G =< V, E >$ 为二分图，如果 $\subseteq E$ ，并且 $M$ 中任意两条边都没有公共端点（即没有边共用一个顶点），则称 $M$ 为 $G$ 的一个匹配。
最大匹配：
- 在所有匹配中，边数最多的匹配称为最大匹配。
完备匹配与完全匹配：
- 若 $X$ 中的所有顶点都是匹配 $M$ 中的端点，则称 $M$ 为 $X$ 的完备匹配。
- 若 $M$ 既是 $X$ -完备匹配又是 $Y$ -完备匹配，则称 $M$ 为 $G$ 的完全匹配（也称完美匹配）。

2. 判定方法

2.1 原理

无向图 $G$ 为二分图的一个充要条件是 $G$ 中不存在奇圈（即所有回路的长度均为偶数）。这一性质是二分图判定的核心依据。

2.2 实现方法

染色法：
- 任意选择一个顶点并赋予颜色1（或称为红色），放入集合 $U$ 。
- 将该顶点的所有未染色邻居顶点赋予颜色2（或称为蓝色），放入集合 $V$ 。
- 依次对集合 $V$ 中的每个顶点重复上述过程，直到所有顶点都被染色或发现矛盾（即存在边连接的两个顶点颜色相同）。
- 如果所有顶点都被成功染色，则图是二分图；否则，不是二分图。

代码实现（DFS版本）：

def dfs(graph, color, vertex, color_value):
 """
 Perform DFS to color the graph and check if it's bipartite.
 """
 color[vertex] = color_value
 for neighbor in range(len(graph)):
     if graph[vertex][neighbor]:
         if color[neighbor] == -1:
             if not dfs(graph, color, neighbor, 1 - color_value):
                 return False
         elif color[neighbor] == color_value:
             return False
 return True

 def is_bipartite(graph):
     """
     Check if the given graph is bipartite.
     """
     n = len(graph)
     if n == 0:
         return True  # An empty graph is trivially bipartite
     
     color = [-1] * n
     for i in range(n):
         if color[i] == -1:
             if not dfs(graph, color, i, 0):
                 return False
     return True

3. 匈牙利算法求解最大匹配

3.1 原理

匈牙利算法通过不断寻找增广路（也称为增广轨或交错轨）来增加匹配中的边数，直到无法找到新的增广路为止，此时得到的匹配即为最大匹配。

3.2 实现步骤

初始化匹配集 $M$ 为空集。
对每个未匹配点 $u$ ，执行：
- 从 $u$ 出发进行深度优先搜索（DFS），寻找一条增广路。
- 如果找到增广路，则进行增广操作（即反转路径上边的匹配状态），并更新匹配集 $M$ 。
- 重复上述过程，直到无法找到新的增广路为止。

3.3 代码实现

def dfs(graph, match, visited, u):
    """
    Depth-first search to find an augmenting path in the bipartite graph.
    
    :param graph: Adjacency matrix of the bipartite graph.
    :param match: Current matching state.
    :param visited: Visited nodes in the current DFS.
    :param u: Current node to start DFS from.
    :return: True if an augmenting path is found, False otherwise.
    """
    for v in range(len(graph[u])):
        if graph[u][v] and not visited[v]:
            visited[v] = True
            if match[v] == -1 or dfs(graph, match, visited, match[v]):
                match[v] = u
                return True
    return False

def hungarian(graph):
    """
    Hungarian algorithm to find the maximum matching in a bipartite graph.
    
    :param graph: Adjacency matrix of the bipartite graph.
    :return: The size of the maximum matching.
    """
    n = len(graph)
    match = [-1] * n  # Initialize match array with -1 (no matches initially)
    result = 0
    
    for u in range(n):
        visited = [False] * n  # Reset visited array for each new DFS
        if dfs(graph, match, visited, u):
            result += 1
    
    return result