地图着色问题

IT小艺

于 2023-01-04 23:11:11 发布

阅读量892

点赞数

文章标签：算法 Powered by 金山文档

本文链接：https://blog.csdn.net/qq_64079631/article/details/128534601

版权

本文介绍了如何使用深度优先搜索算法对江西省地图上的11个地级市进行着色，每个城市作为图的一个节点，邻接城市颜色不同，目标是最小化颜色使用。程序采用邻接表作为数据结构，初始化所有城市为白色，然后通过递归着色过程确保相邻城市颜色不重复。最后，程序输出每个城市的颜色信息。

摘要由CSDN通过智能技术生成

一、需求分析

问题描述

对江西省地图中的11个地级市进行着色，实际上是无向图用深度优先搜索算法的遍历加上着色操作。

要求：

地图采用图型数据结构，每个地级市为一个节点，边表示对应的两个地级市相邻。

相邻地级市所使用的颜色不同，并保证使用的颜色最少。

设计着色算法，保证邻接点不是同一种颜色。

二、概要设计

1. 设计思路

把11个市看成11个顶点，从选定的第一个顶点开始着色，先试第一种颜色，如果这个颜色与这个顶点的其他邻接顶点的颜色不重复，则这个顶点就是用这种颜色，程序开始对下一个顶点着色，如果着色重复，则使用下一种颜色重复上面的操作。着色过程就是一个递归的过程，直到所有的顶点都处理完后结束着色。

先将每个城市与城市分界线进行数字化，将每个城市的地图颜色设为初始值0即为白色，在循环中判断目前城市的颜色和与当前城市相邻的城市是否存在颜色相同。如果存在就将数字加一（改变颜色），

最终确定所需颜色。

数据结构定义

因为这个程序是对图的操作，所以程序采用的逻辑结构是图状，存储结构选用邻接表，考虑用邻接表是因为一般的地图的某一个顶点并不会与很多的顶点相邻接，如果用邻接矩阵会浪费很多的存储空间，所以选择邻接表来存储。

具体数据结构如下：

typedef struct ArcNode

{

intx; // 表示与当前顶点所表示城市相邻的省份的位置信息

structArcNode *next;

}ArcNode; // 表示城市之间相邻关系的弧结点

typedef struct

{

char*name; // 顶点所表示的城市的名称

intcolor; // // 表示的地图城市的颜色

ArcNode*firstnext; // 指向第一个弧

}City[11];

程序功能模块介绍

该程序一共包含两个模块：分别为颜色选择模块和地图着色模块

1. 颜色选择模块

选择1,2,3,4对应的颜色表示城市的颜色。

2. 地图着色模块

（1）声明表示市的顶点信息、市之间相邻关系的弧的信息，并为其赋值。

（2）使用深度优先搜索的着色算法进行着色。

（3）输出着色结果

运行与调试

因题目已知是江西省地图，有11个市，为地图染色，将地图的节点关系提前赋值到图结构，所以此程序没有地图的输入。

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

typedef struct ArcNode
{
    int x;         // 表示与当前顶点所表示城市相邻的省份的位置信息
    struct ArcNode *next;
}ArcNode;       // 表示城市之间相邻关系的弧结点

typedef struct
{
    char *name;   // 顶点所表示的城市的名称
    int color;    // // 表示的地图城市的颜色
    ArcNode *firstnext;  // 指向第一个弧
}City[11];

int main()
{    
    City city;
    int i,j;
    ArcNode
*p,*hu1,*hu2,*hu3,*hu4,*hu5,*hu6,*hu7,*hu8,*hu9,*hu10,*hu11,*hu12,*hu13,*hu14,*hu15,*hu16,*hu17,*hu18;
    ArcNode *hu19,*hu20,*hu21,*hu22,*hu23,*hu24,*hu25,*hu26,*hu27,*hu28,*hu29,*hu30,*hu31,*hu32,*hu33,*hu34,*hu35;
    ArcNode *hu36,*hu37,*hu38;
//声明表示城市顶点的信息
    hu1=(ArcNode *)malloc(sizeof(ArcNode));
    hu2=(ArcNode *)malloc(sizeof(ArcNode));
    hu3=(ArcNode *)malloc(sizeof(ArcNode));
    hu4=(ArcNode *)malloc(sizeof(ArcNode));
    hu5=(ArcNode *)malloc(sizeof(ArcNode));
    hu6=(ArcNode *)malloc(sizeof(ArcNode));
    hu7=(ArcNode *)malloc(sizeof(ArcNode));
    hu8=(ArcNode *)malloc(sizeof(ArcNode));
    hu9=(ArcNode *)malloc(sizeof(ArcNode));
    hu10=(ArcNode *)malloc(sizeof(ArcNode));
    hu11=(ArcNode *)malloc(sizeof(ArcNode));
    hu12=(ArcNode *)malloc(sizeof(ArcNode));
    hu13=(ArcNode *)malloc(sizeof(ArcNode));
    hu14=(ArcNode *)malloc(sizeof(ArcNode));
    hu15=(ArcNode *)malloc(sizeof(ArcNode));
    hu16=(ArcNode *)malloc(sizeof(ArcNode));
    hu17=(ArcNode *)malloc(sizeof(ArcNode));
    hu18=(ArcNode *)malloc(sizeof(ArcNode));
    hu19=(ArcNode *)malloc(sizeof(ArcNode));
    hu20=(ArcNode *)malloc(sizeof(ArcNode));
    hu21=(ArcNode *)malloc(sizeof(ArcNode));
    hu22=(ArcNode *)malloc(sizeof(ArcNode));
    hu23=(ArcNode *)malloc(sizeof(ArcNode));
    hu24=(ArcNode *)malloc(sizeof(ArcNode));
    hu25=(ArcNode *)malloc(sizeof(ArcNode));
    hu26=(ArcNode *)malloc(sizeof(ArcNode));
    hu27=(ArcNode *)malloc(sizeof(ArcNode));
    hu28=(ArcNode *)malloc(sizeof(ArcNode));
    hu29=(ArcNode *)malloc(sizeof(ArcNode));
    hu30=(ArcNode *)malloc(sizeof(ArcNode));
    hu31=(ArcNode *)malloc(sizeof(ArcNode));
    hu32=(ArcNode *)malloc(sizeof(ArcNode));
    hu33=(ArcNode *)malloc(sizeof(ArcNode));
    hu34=(ArcNode *)malloc(sizeof(ArcNode));
    hu35=(ArcNode *)malloc(sizeof(ArcNode));
    hu36=(ArcNode *)malloc(sizeof(ArcNode));
    hu37=(ArcNode *)malloc(sizeof(ArcNode));
    hu38=(ArcNode *)malloc(sizeof(ArcNode));
    
    city[1].name="赣州市";
    hu1->x=2;
    hu2->x=6;
    city[1].firstnext=hu1;//声名表示城市之间相邻的弧    
    hu1->next=hu2;
    hu2->next=NULL;
    
    city[2].name="吉安市";
    hu3->x=3;
    hu4->x=4;
    hu5->x=5;
    hu6->x=6;
    hu7->x=1;
    city[2].firstnext=hu3;
    hu3->next=hu4;
    hu4->next=hu5;
    hu5->next=hu6;
    hu6->next=hu7;
    hu7->next=NULL;
    
    city[3].name="萍乡市";
    hu8->x=4;
    hu9->x=2;
    city[3].firstnext=hu8;
    hu8->next=hu9;
    hu9->next=NULL;
    
    city[4].name="宜春市";
    hu10->x=5;
    hu11->x=6;
    hu12->x=7;
    hu13->x=8; 
    hu14->x=3; 
    hu15->x=2; 
    city[4].firstnext=hu10;
    hu10->next=hu11;
    hu11->next=hu12;
    hu12->next=hu13;
    hu13->next=hu14;
    hu14->next=hu15;
    hu15->next=NULL;
    
    city[5].name="新余市";
    hu16->x=4;
    hu17->x=2;
    city[5].firstnext=hu16;
    hu16->next=hu17;
    hu17->next=NULL;
    
    city[6].name="抚州市";
    hu18->x=7;
    hu19->x=9;
    hu20->x=10;
    hu21->x=4;
    hu22->x=2; 
    hu23->x=1; 
    city[6].firstnext=hu18;
    hu18->next=hu19;
    hu19->next=hu20;
    hu20->next=hu21;
    hu21->next=hu22;
    hu22->next=hu23;    
    hu23->next=NULL;
    
    city[7].name="南昌市";
    hu24->x=8; 
    hu25->x=10;
    hu26->x=6;
    hu27->x=4;
    city[7].firstnext=hu24;
    hu24->next=hu25;
    hu25->next=hu26;
    hu26->next=hu27;
    hu27->next=NULL;
    
    city[8].name="九江市";
    hu28->x=10;
    hu29->x=7;
    hu30->x=4;    
    city[8].firstnext=hu28;
    hu28->next=hu29;
    hu29->next=hu30;
    hu30->next=NULL;
    
    city[9].name="鹰潭市";
    hu31->x=10;
    hu32->x=6;
    city[9].firstnext=hu31;
    hu31->next=hu32;    
    hu32->next=NULL;
    
    city[10].name="上饶市";
    hu33->x=11;
    hu34->x=9;
    hu35->x=8;
    hu36->x=7;
    hu37->x=6;
    city[10].firstnext=hu33;
    hu33->next=hu34;
    hu34->next=hu35;
    hu35->next=hu36;
    hu36->next=hu37;
    hu37->next=NULL;
    
    city[11].name="景德镇市";
    hu38->x=10;
    city[11].firstnext=hu38;
    hu38->next=NULL;
    
/*--------着色算法------------*/
    for(i=1;i<=11;i++)
    {
        city[i].color=0;   // 初始化所有城市的颜色为白色
    }
    // 对每个城市进行染色
    for(i=1;i<=11;i++)
    {
        j=1;         // 从第一种颜色开始尝试
        p=city[i].firstnext;
        // 对于与当前城市相邻的城市，依次尝试每种颜色
        while(p!=NULL)
        { 
            p=city[i].firstnext;
            while(p!=NULL&&j!=city[p->x].color)
            {
                p=p->next;
            }
            if(p!=NULL)  // 如果找到了与相邻城市颜色相同的颜色，则尝试下一种颜色
                j++;
        }
        city[i].color=j;        // 最终确定的颜色
    }
    system("color 0C");
    //输出各城市颜色信息
    printf("着色结果为:\n");
    printf("\n 0表示白色,1表示红色,2表示绿色,3表示蓝色,4表示橙黄色\n");
    //分别为各城市着色
    for(i=1;i<=11;i++)
    {
        printf("%s:",city[i].name);
        if(city[i].color==0)                 
        printf("%d  白色\n",city[i].color);                
        else if(city[i].color==1)             
        printf("%d  红色\n",city[i].color);                
        else if(city[i].color==2) 
        printf("%d  绿色\n",city[i].color);                
        else if(city[i].color==3) 
        printf("%d  蓝色\n",city[i].color);        
        else if(city[i].color==4) 
        printf("%d  橙黄色\n",city[i].color);                
        else
        printf("  无色");                 
    }
    
    return 0;
    }