4205 树的增边（二分图染色）

1. 问题描述： 

二分图又称作二部图，是图论中的一种特殊模型。设 G = (V，E) 是一个无向图，如果顶点 V 可分割为两个互不相交的子集 (A，B)，并且图中的每条边 (i，j) 所关联的两个顶点 i 和 j 分别属于这两个不同的顶点集 (i∈A，j∈B)，则称图 G 为一个二分图。 所有的树都是二分图。给定一个 n 个节点的树。树的节点编号为 1∼n。请你为这棵树增加一些边，要求增边后的图形仍是二分图，并且不含重边和自环。请问，最多可以增加多少条边。

输入格式

第一行包含整数 n，表示树的节点数量。接下来 n−1 行，每行包含两个整数 a，b，表示节点 a 和节点 b 之间存在一条边。

输出格式

一个整数，表示可以增加的边的最大数量。

数据范围

前三个测试点满足 1 ≤ n ≤ 10。
所有测试点满足 1 ≤ n ≤ 10 ^ 5，1 ≤ a，b ≤ n。

输入样例1：

3
1 2
1 3

输出样例1：

0

输入样例2：

5
1 2
2 3
3 4
4 5

输出样例2：

2
来源：https://www.acwing.com/problem/content/description/4208/

2. 思路分析：

二分图中有三个等价关系，如下图所示，这三个等价关系是可以相互论证的：

由题目可知是一棵树所以不存在长度为奇数的环所以染色法是不存在矛盾的，所以树是一个二分图，我们可以对树中的所有节点通过染色分类，当根节点的颜色确定之后那么整棵树的颜色就是确定的，最终树中的节点就可以分为两大类，由于最终要使得添加边之后还是一个二分图所以只能够在两个集合之间加边，不能够在集合内部加边所以最终最多添加的边数为m * (n - m) - (n - 1)，其中m为树中染成一种颜色的数目（例如在下面的bfs代码中一开始根节点的颜色染成颜色0），一个集合中的点与另外一个集合中的点的所有点都有边：

3. 代码如下：

bfs：

import collections
from typing import List


class Solution:
    # 在bfs遍历节点的过程中进行染色
    def bfs(self, u: int, n: int, g: List[List[int]]):
        # m统计染成白色的点的数量
        m = 0
        q = collections.deque([u])
        st = [-1] * (n + 10)
        st[u] = 0
        while q:
            p = q.popleft()
            if st[p] == 0: m += 1
            for next in g[p]:
                # 当前的节点还没有染色
                if st[next] == -1:
                    # 染成相反的颜色
                    st[next] = st[p] ^ 1
                    q.append(next)
        return m

    def process(self):
        n = int(input())
        g = [list() for i in range(n + 10)]
        for i in range(n - 1):
            a, b = map(int, input().split())
            # 无向边
            g[a].append(b)
            g[b].append(a)
        m = self.bfs(1, n, g)
        return m * (n - m) - (n - 1)


if __name__ == '__main__':
    print(Solution().process())

dfs：提交上去发生段错误，一般对于节点个数非常多的图使用dfs会发生爆栈的错误，所以当节点数目比较大的时候能够使用bfs就使用bfs来解决：

from typing import List
import sys

class Solution:
    m = None

    def dfs(self, u: int, color: int, fa: int, g: List[List[int]]):
        if color == 0: self.m += 1
        for next in g[u]:
            if next == fa: continue
            self.dfs(next, color ^ 1, u, g)

    def process(self):
        n = int(input())
        g = [list() for i in range(n + 10)]
        for i in range(n - 1):
            a, b = map(int, input().split())
            # 无向边
            g[a].append(b)
            g[b].append(a)
        self.m = 0
        # 因为存储的是两个方向的边所以需要传递一个父节点防止重复搜索
        self.dfs(1, 0, -1, g)
        return self.m * (n - self.m) - (n - 1)


if __name__ == '__main__':
    sys.setrecursionlimit(1000000)
    print(Solution().process())