算法分析设计实践——M着色问题

1. 问题

给定无向连通图G=（V,E）和M中不同的角色，用这些颜色为图G的个顶点着色，每个顶点着一种颜色。是否有一种着色算法是G中相邻的两个顶点有不同的颜色？给出所有可能的着色方案；如果不存在，则回答“NO”

2.解析

回溯法

使用回溯法，具体步骤是将cur=1传入dfs（），即从第一个开始涂色。

　　涂的时候从颜色1开始到m，每当涂上一个色，要用checked（cur）判断第cur个点是否可以涂这个色，不可以的话就不再往下涂了，改试另一个颜色，可以的话就继续。

　　　　当cur>n的时候即前n个点都涂完了，然后输出结果并cnt++计数。

3.设计

bool check(int c){
    for(int k=1;k<=n;k++){
        if(graph[c][k]&&color[c]==color[k]){
            return false;
        }
    }
    return true;
}

void dfs(int cur){
    if(cur>n){
        for(int i=1;i<=n;i++){
            printf("%d ",color[i]);
        }
        cnt++;
        printf("
");
    }else{
        for(int i=1;i<=m;i++){
            color[cur]=i;
            if(check(cur)){
                dfs(cur+1);
            }
            color[cur]=0;
        }
    }
}

4.完整代码

#include <iostream>
#include <cstdio>

using namespace std;

int n,m;
int a=1,b=1;
int cnt=0;
int graph[20][20]={0};
int color[20]={0};

bool check(int c){
    for(int k=1;k<=n;k++){
        if(graph[c][k]&&color[c]==color[k]){
            return false;
        }
    }
    return true;
}

void dfs(int cur){
    if(cur>n){
        for(int i=1;i<=n;i++){
            printf("%d ",color[i]);
        }
        cnt++;
        printf("
");
    }else{
        for(int i=1;i<=m;i++){
            color[cur]=i;
            if(check(cur)){
                dfs(cur+1);
            }
            color[cur]=0;
        }
    }
}

int main()
{
    scanf("%d %d",&n,&m);
    while(scanf("%d %d",&a,&b)!=EOF&&a!=0&&b!=0){
        graph[a][b]=1;
        graph[b][a]=1;
    }
    dfs(1);
    if(cnt > 0)
    {
        printf("Total=%d",cnt);
    }
    else
    {
        printf("NO
");
    }
    
    return 0;
}
/*
样例输入：
5 4
1 3
1 2
1 4
2 3
2 4
2 5
3 4
4 5
0 0

样例输出：
1 2 3 4 1 
1 2 3 4 3 
1 2 4 3 1 
1 2 4 3 4 
1 3 2 4 1 
1 3 2 4 2
1 3 4 2 1 
1 3 4 2 4 
1 4 2 3 1 
1 4 2 3 2 
1 4 3 2 1 
1 4 3 2 3 
2 1 3 4 2 
2 1 3 4 3 
2 1 4 3 2 
2 1 4 3 4 
2 3 1 4 1 
2 3 1 4 2 
2 3 4 1 2 
2 3 4 1 4 
2 4 1 3 1 
2 4 1 3 2 
2 4 3 1 2 
2 4 3 1 3 
3 1 2 4 2 
3 1 2 4 3 
3 1 4 2 3 
3 1 4 2 4 
3 2 1 4 1 
3 2 1 4 3 
3 2 4 1 3 
3 2 4 1 4 
3 4 1 2 1 
3 4 1 2 3 
3 4 2 1 2 
3 4 2 1 3 
4 1 2 3 2 
4 1 2 3 4 
4 1 3 2 3 
4 1 3 2 4 
4 2 1 3 1 
4 2 1 3 4 
4 2 3 1 3 
4 2 3 1 4 
4 3 1 2 1 
4 3 1 2 4 
4 3 2 1 2 
4 3 2 1 4 
Total=48


*/

5.分析

空间复杂度：O（n）

6.源码

https://github.com/BambooCertain/Algorithm.git