回溯法-图的m着色问题

图的 m 着色问题

问题描述

给定一个无向连通图 ( G = (V, E) ) 和 ( m ) 种颜色，我们的任务是为图 ( G ) 的每个顶点着色，使得相邻的顶点颜色不同。如果存在这样的着色方案，我们称之为图 ( G ) 的 ( m ) 可着色问题。

算法思路

1. 初始化：创建一个二维数组 colors 来记录每个顶点的颜色。
2. 选择起始点：从图中任选一个顶点作为起始点，并为其着色。
3. 相邻顶点着色：对于起始点相邻的顶点，依次尝试着色，确保相邻顶点颜色不同。
4. 回溯：如果某个顶点无法着色，则回溯到上一个顶点，尝试其他颜色。
5. 完成着色：当所有顶点都被成功着色时，记录着色方案。

算法设计

输入

• 图 ( G = (V, E) )，其中 ( V ) 是顶点集合，( E ) 是边集合。
• 颜色数 ( m )。

输出

• 所有可能的着色方案，或者输出 “NO” 表示不存在着色方案。

步骤

1. 构建邻接矩阵：使用一个二维数组 ( a ) 来表示图 ( G ) 的邻接矩阵，其中 ( a[i][j] = 1 ) 表示顶点 ( i ) 和顶点 ( j ) 之间有边。
   
   下图表示 每个顶点有m种 着色方法

3. 着色过程：

• 从顶点 ( 1 ) 开始，尝试为其着色。
• 对于每个顶点 ( i )，检查所有相邻顶点 ( j )，确保 ( x[i] ≠ x[j] )。
• 如果当前颜色无法满足条件，尝试下一个颜色，直到找到合适的颜色或所有颜色都尝试完毕。
• 如果所有颜色都无法满足条件，则回溯到上一个顶点，改变其颜色。

4. 记录着色方案：当所有顶点都被着色时，记录当前的着色方案。

示例

假设我们有一个图 ( G ) 包含 4个顶点，我们尝试使用 3 种颜色对其进行着色。通过上述算法，我们可以找到所有可能的着色方案。

假设的图 ( G ) 和颜色

• 顶点集合 ( V = {1, 2, 3, 4} )
• 边集合 ( E = {(1, 2), (1, 3), (2, 3), (3, 4)} )
• 颜色集合 ( C = {红, 蓝, 绿} )

步骤

1. 构建邻接矩阵

首先，我们需要构建一个邻接矩阵来表示图中顶点之间的连接关系。如果顶点 ( i ) 和顶点 ( j ) 之间有边，则 ( a[i][j] = 1 )，否则 ( a[i][j] = 0 )。

	1	2	3	4
1	0	1	1	0
2	1	0	1	0
3	1	1	0	1
4	0	0	1	0

2. 着色过程

我们将使用回溯法来尝试为每个顶点着色。

2.1 选择起始点

我们从顶点 1 开始着色。

2.2 为顶点 1 着色

我们尝试为顶点 1 着色。由于没有相邻的顶点，我们可以任意选择一种颜色。假设我们选择红色。

• 颜色数组：[ 红, _ , _ , _ ]

2.3 为顶点 2 着色

顶点 2 与顶点 1 相邻，因此不能着同样的颜色（红色）。我们尝试其他颜色。

• 尝试蓝色：可以，因为与顶点 1 不同。
• 颜色数组：[ 红, 蓝, _ , _ ]

2.4 为顶点 3 着色

顶点 3 与顶点 1 和 2 相邻，因此不能着红色或蓝色。

• 尝试绿色：可以，因为与顶点 1 和 2 不同。
• 颜色数组：[ 红, 蓝, 绿, _ ]

2.5 为顶点 4 着色

顶点 4 与顶点 3 相邻，因此不能着绿色。

• 尝试红色：不可以，因为与顶点 3 相同。
• 尝试蓝色：可以。
• 颜色数组：[ 红, 蓝, 绿, 蓝 ]

3. 完成着色

我们成功为所有顶点着色，得到一个有效的着色方案。

代码

#include "stdio.h"

// 定义全局变量
int n, m; // n 是图中顶点的数量，m 是可以使用的颜色数量

int a[100][100]; // 定义一个 100x100 的二维数组 a，用来存储图的邻接矩阵
int x[100]; // 定义一个数组 x，用来存储当前顶点的着色方案
int sum = 0; // 定义一个变量 sum，用来记录总共找到的着色方案的数量

// 输入函数，用于获取用户输入的图的信息
void input() {
    printf("输入顶点数n和着色数m:\n"); // 提示用户输入顶点数和颜色数
    scanf("%d %d", &n, &m); // 读取用户输入的顶点数和颜色数

    printf("输入无向图的邻接矩阵:\n"); // 提示用户输入邻接矩阵
    for (int i = 1; i <= n; i++) { // 遍历每个顶点
        for (int j = 1; j <= n; j++) // 遍历每个顶点的邻接顶点
            scanf("%d", &a[i][j]); // 读取邻接矩阵的值
        printf("\n"); // 换行
    }
}

// 检查函数，用于检查当前顶点是否可以着指定颜色
int ok(int k) {
    for (int j = 1; j <= n; j++) // 遍历所有顶点
        if (a[k][j] && (x[j] == x[k])) // 如果顶点 k 和顶点 j 相邻，并且颜色相同
            return 0; // 返回 0，表示不可以着这个颜色
    return 1; // 返回 1，表示可以着这个颜色
}

// 回溯函数，用于尝试所有可能的着色方案
void backtrack(int t) {
    if (t > n) { // 如果已经为所有顶点尝试了着色
        sum++; // 着色方案数加一
    } else {
        for (int i = 1; i <= m; i++) { // 尝试每种颜色
            x[t] = i; // 给顶点 t 着色
            if (ok(t) == 1) backtrack(t + 1); // 如果可以着这个颜色，递归尝试下一个顶点
            x[t] = 0; // 回溯，撤销当前顶点的着色
        }
    }
}

// 主函数，用于启动着色算法
int color() {
    sum = 0; // 初始化着色方案数为 0
    backtrack(1); // 从第一个顶点开始尝试着色
    return sum; // 返回找到的着色方案数
}

// 主函数，程序的入口
int main() {
    input(); // 调用输入函数
    color(); // 调用着色函数
    printf("着色方案数为：%d\n", sum); // 输出找到的着色方案数
    return 0; // 程序结束
}

复杂度分析

图m可着色问题的解空间树中，内结点个数是：

对于每一个内结点，在最坏情况下，用ok检查当前扩展结点每一个儿子的颜色可用性需耗时O(mn)。

因此，回溯法总的时间耗费是