1.问题描述
1.1设计内容
已知中国地图，对各省进行着色，要求相邻省所使用的颜色不同，并保证使用的颜色总数最少。
1.2设计要求
（1）设计该问题的核心算法；
（2）设计可视化的界面，界面中能显示和区分中国地图中各省、市、自治区；
（3）程序能正确对地图着色。
2.方法及基本思路
本题抽象出来其实就是着色问题：已知一个图，要求给图上每个点上色，并保证该点的颜色与它的邻接点的颜色都不相同。
回溯法的基本思想是：在解空间中，按深度优先策略，从根结点出发搜索，搜索至任一节点时，先判断该节点是否包含问题的解。如果不包含，则跳过以该节点为根的子节点，逐层向其父节点回溯。否则，进入该子树，继续按照深度优先策略搜索。
假设地图邻接关系如右所示，那么它的状态解空间树如左图所示：
3.算法描述
算法名称：回溯法
输入：34个省份
输出：每个省份的颜色
省份着色(Graph) :
1. 初始化变量：
着色颜色数 colorCount = 0
最小着色颜色数 minColorCount = ∞
2. 对于图中的每个省份节点 v，设置其颜色 color[v] = 0
3. 对于图中的每个省份节点 v，将其未使用的颜色 mark[v][c] = true
4. 递归着色(0) // 从第一个省份节点开始着色
5. 输出结果最小着色颜色数 minColorCount
递归着色(v) :
1. 如果当前省份节点 v 是最后一个节点：
更新最小着色颜色数 minColorCount = colorCount
返回
2. 对于每一种颜色 c 从 1 到 maxColors：
If:省份节点 v 可以使用颜色 c：
设置 color[v] = c
对于省份节点 v 的每一个相邻节点 u，更新 mark[u][c] = false
颜色数 colorCount++
递归着色(v + 1)
颜色数 colorCount --
对于省份节点 v 的每一个相邻节点 u，更新 mark[u][c] = true
If: colorCount > minColorCount:
说明当前方案无效，回溯到上一个节点
4.时间空间复杂度分析
基本运算：比较
递归公式：T(N, k) = k * T(N-1, k-1)
时间复杂度：O(k^N)
在最坏情况下，算法需要遍历所有可能的颜色方案，所以时间复杂度为 O(k^N)，其中 k 是可用的颜色数，N 是省份节点的数量。
空间复杂度：O(N)
递归调用栈的深度最大为省份节点的数量 N，所以空间复杂度为 O(N)。
5.算法实例
输入数据：输入34个省份以及各省邻接关系
输出数据：如下图，由于C语言不支持可视化，改为用省份颜色表示着色，一共得到四种颜色，且相邻省份颜色不同。
6.源码
参考链接
这位博主的代码可在Dev C++下运行；以下是我稍作修改，可以在VS2022中运行的代码，并为此添加了注释
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#include "string.h"
#include<time.h>
// 定义一个结构体ArcNode，表示省份之间的连接关系
typedef struct ArcNode {
int apn; // 相邻省的序号，即连接的省份
struct ArcNode* nextarc; // 指向下一个ArcNode的指针，表示下一个连接的省份
} ArcNode;
// 定义一个结构体VNode，表示一个省份的信息
typedef struct VNode {
char name[6];
int color;
int number;
ArcNode* firstarc; // 指向该省份的第一个连接关系的指针
} VNode;
// 定义一个结构体DNode，表示双链表的一个节点
typedef struct DLinkNode {
struct VNode* data; // 指向VNode的指针，作为双链表节点的数据
struct DLinkNode* prior; // 指向前一个DLinkNode的指针
struct DLinkNode* next; // 指向下一个DLinkNode的指针
} DLinkNode;
// 定义一个数组，存储ArcNode的指针，最多可以存储145个省份的连接关系
ArcNode* node[145], * p;
// 定义一个数组，存储VNode的实例，最多可以存储35个省份的信息
VNode province[35];
// 定义一个二维数组，存储每个省份的颜色，最多可以存储35个省份的5种颜色（红、绿、蓝、黄、紫）
int color[35][5];
void Intput(VNode* province, ArcNode* node[]); // 输入中国地图信息的函数，参数是省份和连接关系的数组
void Initialization(VNode* province); // 初始化各省颜色及颜色数组
void Painting(VNode* province, ArcNode* p, int i); // 对省份进行上色的函数，参数是省份和指向某个连接关系的指针和省份的序号
void Setcolor(int i); // 设置输出颜色的函数，参数是颜色编号
void Output(VNode* province, ArcNode* p); 输出信息的函数，参数是省份和指向某个连接关系的指针
void Find(DLinkNode*& L, VNode* province, ArcNode* p); // // 求最少着色颜色的函数，参数是双链表的头节点、省份数组和省份的数量
void CreateListR(DLinkNode*& L, VNode* province, int n); // // 使用尾插法创建双链表的函数，参数是双链表的头节点、省份数组和省份的数量
int main() {
DLinkNode* DuLinkLis; // 双链表的头节点指针
Intput(province, node); // 输入中国地图信息
CreateListR(DuLinkLis, province, 34); // 使用尾插法创建双链表
Find(DuLinkLis, province, p); // 求最少着色颜色数
return 0;
}
// 输入中国地图信息的函数实现
void Intput(VNode* province, ArcNode* node[]) {
for (int i = 1; i < 145; i++) // 对145个连接关系进行初始化
node[i] = (ArcNode*)malloc(sizeof(ArcNode)); // 为每个连接关系分配内存空间并初始化为0
for (int i = 1; i < 145; i++) // 对每个连接关系设置相邻省的序号和指向下一个连接关系的指针
node[i]->nextarc = node[i + 1]; // node[i]->nextarc指向node[i+1]，即每个连接关系的下一个连接关系是node[i+1]
strcpy_s(province[1].name, 20,"新疆");
province[1].firstarc = node[1];
node[1]->apn = 2;
node[2]->apn = 3;
node[3]->apn = 4;
node[3]->nextarc = NULL;
strcpy_s(province[2].name, 20,"西藏");
province[2].firstarc = node[4];
node[4]->apn = 1;
node[5]->apn = 3;
node[6]->apn = 7;
node[7]->apn = 8;
node[7]->nextarc = NULL;
strcpy_s(province[3].name, 20,"青海");
province[3].firstarc = node[8];
node[8]->apn = 1;
node[9]->apn = 2;
node[10]->apn = 4;
node[11]->apn = 7;
node[11]->nextarc = NULL;
strcpy_s(province[4].name,20, "甘肃");
province[4].firstarc = node[12];
node[12]->apn = 1;
node[13]->apn = 3;
node[14]->apn = 5;
node[15]->apn = 6;
node[16]->apn = 7;
node[17]->apn = 9;
node[17]->nextarc = NULL;
strcpy_s(province[5].name,20, "内蒙古");
province[5].firstarc = node[18];
node[18]->apn = 4;
node[19]->apn = 6;
node[20]->apn = 9;
node[21]->apn = 13;
node[22]->apn = 21;
node[23]->apn = 32;
node[24]->apn = 33;
node[25]->apn = 34;
node[25]->nextarc = NULL;
strcpy_s(province[6].name, 20,"宁夏");
province[6].firstarc = node[26];
node[26]->apn = 4;
node[27]->apn = 5;
node[28]->apn = 9;
node[28]->nextarc = NULL;
strcpy_s(province[7].name,20, "四川");
province[7].firstarc = node[29];
node[29]->apn = 2;
node[30]->apn = 3;
node[31]->apn = 4;
node[32]->apn = 8;
node[33]->apn = 9;
node[34]->apn = 10;
node[35]->apn = 11;
node[35]->nextarc = NULL;
strcpy_s(province[8].name, 20,"云南");
province[8].firstarc = node[36];
node[36]->apn = 2;
node[37]->apn = 7;
node[38]->apn = 11;
node[39]->apn = 12;
node[39]->nextarc = NULL;
strcpy_s(province[9].name,20, "陕西");
province[9].firstarc = node[40];
node[40]->apn = 4;
node[41]->apn = 5;
node[42]->apn = 6;
node[43]->apn = 7;
node[44]->apn = 10;
node[45]->apn = 13;
node[46]->apn = 14;
node[47]->apn = 15;
node[47]->nextarc = NULL;
strcpy_s(province[10].name, 20,"重庆");
province[10].firstarc = node[48];
node[48]->apn = 7;
node[49]->apn = 9;
node[50]->apn = 11;
node[51]->apn = 15;
node[52]->apn = 16;
node[52]->nextarc = NULL;
strcpy_s(province[11].name,20, "贵州");
province[11].firstarc = node[53];
node[53]->apn = 7;
node[54]->apn = 8;
node[55]->apn = 10;
node[56]->apn = 12;
node[57]->apn = 16;
node[57]->nextarc = NULL;
strcpy_s(province[12].name, 20,"广西");
province[12].firstarc = node[58];
node[58]->apn = 8;
node[59]->apn = 11;
node[60]->apn = 16;
node[61]->apn = 17;
node[61]->nextarc = NULL;
strcpy_s(province[13].name, 20,"山西");
province[13].firstarc = node[62];
node[62]->apn = 5;
node[63]->apn = 9;
node[64]->apn = 14;
node[65]->apn = 21;
node[65]->nextarc = NULL;
strcpy_s(province[14].name,20, "河南");
province[14].firstarc = node[66];
node[66]->apn = 9;
node[67]->apn = 13;
node[68]->apn = 15;
node[69]->apn = 21;
node[70]->apn = 24;
node[71]->apn = 25;
node[71]->nextarc = NULL;
strcpy_s(province[15].name, 20,"湖北");
province[15].firstarc = node[73];
node[73]->apn = 9;
node[74]->apn = 10;
node[75]->apn = 14;
node[76]->apn = 16;
node[77]->apn = 25;
node[78]->apn = 26;
node[78]->nextarc = NULL;
strcpy_s(province[16].name,20,"湖南");
province[16].firstarc = node[79];
node[79]->apn = 10;
node[80]->apn = 11;
node[81]->apn = 12;
node[82]->apn = 15;
node[83]->apn = 17;
node[84]->apn = 26;
node[84]->nextarc = NULL;
strcpy_s(province[17].name,20, "广东");
province[17].firstarc = node[85];
node[85]->apn = 12;
node[86]->apn = 16;
node[87]->apn = 19;
node[88]->apn = 20;
node[89]->apn = 26;
node[90]->apn = 30;
node[90]->nextarc = NULL;
strcpy_s(province[18].name, 20,"海南");
province[18].firstarc = NULL;
strcpy_s(province[19].name,20, "澳门");
province[19].firstarc = node[91];
node[91]->apn = 17;
node[91]->nextarc = NULL;
strcpy_s(province[20].name,20, "香港");
province[20].firstarc = node[92];
node[92]->apn = 17;
node[92]->nextarc = NULL;
strcpy_s(province[21].name,20, "河北");
province[21].firstarc = node[93];
node[93]->apn = 5;
node[94]->apn = 13;
node[95]->apn = 14;
node[96]->apn = 22;
node[97]->apn = 23;
node[98]->apn = 24;
node[99]->apn = 34;
node[99]->nextarc = NULL;
strcpy_s(province[22].name, 20,"北京");
province[22].firstarc = node[100];
node[100]->apn = 21;
node[101]->apn = 23;
node[101]->nextarc = NULL;
strcpy_s(province[23].name,20, "天津");
province[23].firstarc = node[102];
node[102]->apn = 21;
node[103]->apn = 22;
node[103]->nextarc = NULL;
strcpy_s(province[24].name,20, "山东");
province[24].firstarc = node[104];
node[104]->apn = 14;
node[105]->apn = 21;
node[106]->apn = 25;
node[107]->apn = 27;
node[107]->nextarc = NULL;
strcpy_s(province[25].name, 20,"安徽");
province[25].firstarc = node[108];
node[108]->apn = 14;
node[109]->apn = 15;
node[110]->apn = 24;
node[111]->apn = 26;
node[112]->apn = 27;
node[113]->apn = 29;
node[113]->nextarc = NULL;
strcpy_s(province[26].name, 20,"江西");
province[26].firstarc = node[115];
node[115]->apn = 15;
node[116]->apn = 16;
node[117]->apn = 17;
node[118]->apn = 25;
node[119]->apn = 29;
node[120]->apn = 30;
node[120]->nextarc = NULL;
strcpy_s(province[27].name,20, "江苏");
province[27].firstarc = node[122];
node[122]->apn = 24;
node[123]->apn = 25;
node[124]->apn = 28;
node[125]->apn = 29;
node[125]->nextarc = NULL;
strcpy_s(province[28].name,20, "上海");
province[28].firstarc = node[126];
node[126]->apn = 27;
node[127]->apn = 29;
node[127]->nextarc = NULL;
strcpy_s(province[29].name,20, "浙江");
province[29].firstarc = node[128];
node[128]->apn = 17;
node[129]->apn = 25;
node[130]->apn = 26;
node[131]->apn = 27;
node[132]->apn = 28;
node[132]->nextarc = NULL;
strcpy_s(province[30].name, 20,"福建");
province[30].firstarc = node[133];
node[133]->apn = 17;
node[134]->apn = 26;
node[135]->apn = 29;
node[135]->nextarc = NULL;
strcpy_s(province[31].name,20, "台湾");
province[31].firstarc = NULL;
strcpy_s(province[32].name, 20,"黑龙江");
province[32].firstarc = node[136];
node[136]->apn = 5;
node[137]->apn = 33;
node[137]->nextarc = NULL;
strcpy_s(province[33].name,20, "吉林");
province[33].firstarc = node[138];
node[138]->apn = 5;
node[139]->apn = 32;
node[140]->apn = 34;
node[140]->nextarc = NULL;
strcpy_s(province[34].name, 20,"辽宁");
province[34].firstarc = node[141];
node[141]->apn = 5;
node[142]->apn = 21;
node[143]->apn = 33;
node[143]->nextarc = NULL;
}
// 初始化函数，对省份数组进行初始化
void Initialization(VNode* province) {
// 循环遍历34个省份
for (int i = 1; i <= 34; i++)
{
// 将省份的颜色初始化为0，表示未被使用
province[i].color = 0;
// 设置省份的序号为i
province[i].number = i;
// 对每个省份，为其颜色属性赋初值，从1到5
for (int j = 0; j < 5; j++)
color[i][j] = j + 1;
}
}
// 创建双链表的函数
void CreateListR(DLinkNode*& L, VNode* province, int n) {
// 定义创建双链表需要的指针s和r，L为双链表的头结点
DLinkNode* s, * r;
// 为头结点分配内存空间
L = (DLinkNode*)malloc(sizeof(DLinkNode)); //创建头结点
// 设置头结点的prior和next指针为空
L->prior = L->next = NULL;
// 设置头结点的数据为省份数组的第一个省份的信息
L->data = &province[1];
// r指针始终指向双链表的终端结点，开始时指向头结点
r = L; //r始终指向终端结点,开始时指向头结点
// 循环创建双链表的结点，从第二个省份开始，直到第n个省份
for (int i = 2; i <= n; i++)
{
// 为新结点分配内存空间
s = (DLinkNode*)malloc(sizeof(DLinkNode));//创建新结点
// 设置新结点的数据为当前省份的信息
s->data = &province[i];
// 将新结点插入到r指针指向的结点之后
r->next = s; s->prior = r; //将结点s插入结点r之后
// r指针指向新插入的结点
r = s;
}
// 将双链表的尾结点的next指针指向头结点，形成环状结构
r->next = L; //尾结点next域置为头节点
// 将头结点的prior指针指向尾结点，形成环状结构
L->prior = r;
}
void Painting(VNode* province, ArcNode* p, int i) {
// 将p指向province数组中第i个省份的第一个邻接省份
p = province[i].firstarc;
// 遍历该省份的所有邻接省份
while (p != NULL)
{
// 根据邻接省份的颜色值进行判断和操作
switch (province[p->apn].color)
{
// 如果邻接省份的颜色值为1，则将当前省份的第0列颜色值设为0 （第一种颜色为0已经使用，不再可用）
case 1:color[i][0] = 0; break;
// 如果邻接省份的颜色值为2，则将当前省份的第1列颜色值设为0
case 2:color[i][1] = 0; break;
// 如果邻接省份的颜色值为3，则将当前省份的第2列颜色值设为0
case 3:color[i][2] = 0; break;
// 如果邻接省份的颜色值为4，则将当前省份的第3列颜色值设为0
case 4:color[i][3] = 0; break;
// 如果邻接省份的颜色值为5，则将当前省份的第4列颜色值设为0
case 5:color[i][4] = 0; break;
// 如果邻接省份的颜色值不在1-5之间，不进行任何操作
default:break;
}
// 移动到下一个邻接省份
p = p->nextarc;
}
// 在当前省份可能被分配的5种颜色中，找出第一个非零颜色值并分配给当前省份
for (int j = 0; j < 5; j++)
{
// 如果第j列的颜色值不为0
if (color[i][j] != 0)
{
// 将第j列的颜色值赋给当前省份，并重置第j列的颜色值为0
province[i].color = color[i][j];
color[i][j] = 0;
// 跳出循环，因为已经找到了一个有效的颜色值
break;
}
}
}
void Setcolor(int i) // 定义一个函数Setcolor，接收一个整数参数i
{
HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);// 获取标准输出句柄是一个Windows API函数，用于获取标准输出的句柄。通过这个句柄，你可以对标准输出进行各种操作，比如改变文本颜色、设置文本位置等。
switch (i)
{
case 1:SetConsoleTextAttribute(handle, FOREGROUND_INTENSITY | FOREGROUND_GREEN); break;//绿色
case 2:SetConsoleTextAttribute(handle, FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN); break;//黄色
case 3:SetConsoleTextAttribute(handle, FOREGROUND_INTENSITY | FOREGROUND_RED); break;//红色
case 4:SetConsoleTextAttribute(handle, FOREGROUND_INTENSITY | FOREGROUND_BLUE); break;//蓝色
case 5:SetConsoleTextAttribute(handle, FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_BLUE); break;//紫色
case 6:SetConsoleTextAttribute(handle, FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_BLUE); break;//浅蓝
case 7:SetConsoleTextAttribute(handle, FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE); break;//白色
case 8:SetConsoleTextAttribute(handle, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE); break;//默认低亮白色
}
}
void Output(VNode* province, ArcNode* p) { // 定义一个函数Output，接收两个指针参数：省份节点和弧节点
printf("\n中国34个省份颜色如下：\n"); // 打印提示信息，表示接下来将展示34个省份的颜色
for (int i = 1; i <= 34; i++) // 遍历每个省份
{
Setcolor(province[i].color); // 设置当前省份的颜色
printf("%d %s\t", i, province[i].name); // 打印省份的序号和名称
if (i % 12 == 0) // 如果省份序号是12的倍数
printf("\n"); // 则换行
}
Setcolor(8); // 将颜色设置回默认颜色（8）
printf("\n\n"); // 打印两个换行符
printf("\n中国34个省份颜色及其各邻接省份颜色如下请查阅：\n"); // 打印提示信息，表示接下来将展示每个省份及其邻接省份的颜色
for (int j = 1; j <= 7; j++) // 遍历每个颜色（这里假设有7种颜色）
{
for (int i = 1; i <= 34; i++) // 遍历每个省份
if (province[i].color == j) // 如果该省份的颜色与当前颜色j相同
{
Setcolor(province[i].color); // 设置当前省份的颜色
printf("%d\t%s\t", i, province[i].name); // 打印省份的序号、名称和颜色
Setcolor(8); // 将颜色设置回默认颜色（8）
printf("邻接省份有:"); // 打印提示信息，表示接下来将展示该省份的邻接省份
p = province[i].firstarc; // 从当前省份开始获取其邻接省份的弧节点
while (p != NULL) // 遍历所有邻接省份的弧节点
{
Setcolor(province[p->apn].color); // 设置邻接省份的颜色
printf("%s ", province[p->apn].name); // 打印邻接省份的名称和颜色
p = p->nextarc; // 移动到下一个邻接省份的弧节点
}
printf("\n"); // 换行
}
printf("\n"); // 在遍历完一个颜色后换行，使得每个颜色的省份都在新的一行上显示
}
Setcolor(8); // 将颜色设置回默认颜色（8）
}
void Find(DLinkNode*& L, VNode* province, ArcNode* p) { // 函数声明，接收三个指针参数：双向链表L的引用、省份数组province和弧节点数组ArcNode。
DLinkNode* r = L, * s; // 定义两个双向链表节点指针r和s，并初始化r为L的起始节点。
int Maxcolor = 2, Mincolor = 5; // 定义两个整数变量Maxcolor和Mincolor，分别初始化为2和5。
do // 开始一个do-while循环。
{
s = r; // 将s指向r。
Maxcolor = 2; // 将Maxcolor重置为2。
Initialization(province); // 调用Initialization函数来初始化省份数组province。
while (s != s->prior) // 当s不等于其前驱节点时，执行循环。
{
Painting(province, p, s->data->number); // 调用Painting函数，传入省份数组、弧节点数组和当前节点的编号，对地图进行着色。
if (s->data->color > Maxcolor) // 如果当前节点的颜色大于Maxcolor。
if (s->data->number != r->data->number) // 如果当前节点的编号不等于r节点的编号。
{
s->data->color = 0; // 将当前节点的颜色设置为0。
for (int j = 0; j < 5; j++) // 循环初始化颜色数组。
color[s->data->number][j] = j + 1;
s = s->prior; // 将s指向其前驱节点。
goto a; // 跳转到标签a。
}
else // 如果当前节点的编号等于r节点的编号。
{
printf("从第%d个省%s开始着色用%d种颜色着色失败\n", r->data->number, r->data->name, Maxcolor); // 打印失败信息。
Maxcolor++; // 将Maxcolor增加1。
Initialization(province); // 重新初始化省份数组。
s = r; // 将s指向r。
goto a; // 跳转到标签a。
}
if (s->data->number == r->prior->data->number) // 如果当前节点的编号等于r的前驱节点的编号。
{
printf("从第%d个省%s开始着色用%d种颜色着色成功", r->data->number, r->data->name, Maxcolor); // 打印成功信息。
if (Maxcolor < Mincolor)Mincolor = Maxcolor; // 如果Maxcolor小于Mincolor，则更新Mincolor为Maxcolor的值。
Output(province, p); // 调用Output函数，输出省份和邻接省份的信息。
goto b; // 跳转到标签b。
}
s = s->next; // 将s指向其下一个节点。
a:; // 标签a，表示跳转点。
}
b: r = r->next; // 标签b，将r指向其下一个节点。继续下一次循环。
} while (r != L); // 当r不等于L时，继续循环。循环结束条件是r等于L。
Setcolor(4); // 设置文本颜色为4。
printf("\n对中国地图最少着色颜色数为%d种！！\n", Mincolor); // 打印最少需要的颜色数。
Setcolor(8); // 设置文本颜色为8，恢复默认颜色。
return;
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
