第五章【回溯法】最大团问题和图的m着色问题

原文：http://blog.csdn.net/liufeng_king/article/details/8781554

1、最大团问题

     问题描述

     给定无向图G=(V, E)，其中V是非空集合，称为顶点集；E是V中元素构成的无序二元组的集合，称为边集，无向图中的边均是顶点的无序对，无序对常用圆括号“( )”表示。如果U∈V，且对任意两个顶点u，v∈U有(u, v)∈E，则称U是G的完全子图(完全图G就是指图G的每个顶点之间都有连边)。G的完全子图U是G的团当且仅当U不包含在G的更大的完全子图中。G的最大团是指G中所含顶点数最多的团。

     如果U∈V且对任意u，v∈U有(u, v)不属于E，则称U是G的空子图。G的空子图U是G的独立集当且仅当U不包含在G的更大的空子图中。G的最大独立集是G中所含顶点数最多的独立集。

     对于任一无向图G=(V, E)，其补图G'=(V', E')定义为：V'=V，且(u, v)∈E'当且仅当(u, v)∈E。
     如果U是G的完全子图，则它也是G'的空子图，反之亦然。因此，G的团与G'的独立集之间存在一一对应的关系。特殊地，U是G的最大团当且仅当U是G'的最大独立集。

     例：如图所示，给定无向图G={V, E}，其中V={1,2,3,4,5}，E={(1,2), (1,4), (1,5),(2,3), (2,5), (3,5), (4,5)}。根据最大团(MCP)定义，子集{1,2}是图G的一个大小为2的完全子图，但不是一个团，因为它包含于G的更大的完全子图{1,2,5}之中。{1,2,5}是G的一个最大团。{1,4,5}和{2,3,5}也是G的最大团。右侧图是无向图G的补图G'。根据最大独立集定义，{2,4}是G的一个空子图，同时也是G的一个最大独立集。虽然{1,2}也是G'的空子图，但它不是G'的独立集，因为它包含在G'的空子图{1,2,5}中。{1,2,5}是G'的最大独立集。{1,4,5}和{2,3,5}也是G'的最大独立集。

     算法设计

     无向图G的最大团和最大独立集问题都可以用回溯法在O(n2^n)的时间内解决。图G的最大团和最大独立集问题都可以看做是图G的顶点集V的子集选取问题。因此可以用子集树来表示问题的解空间。首先设最大团为一个空团，往其中加入一个顶点，然后依次考虑每个顶点，查看该顶点加入团之后仍然构成一个团，如果可以，考虑将该顶点加入团或者舍弃两种情况，如果不行，直接舍弃，然后递归判断下一顶点。对于无连接或者直接舍弃两种情况，在递归前，可采用剪枝策略来避免无效搜索。为了判断当前顶点加入团之后是否仍是一个团，只需要考虑该顶点和团中顶点是否都有连接。程序中采用了一个比较简单的剪枝策略，即如果剩余未考虑的顶点数加上团中顶点数不大于当前解的顶点数，可停止继续深度搜索，否则继续深度递归当搜索到一个叶结点时，即可停止搜索，此时更新最优解和最优值。

     算法具体实现如下：

[cpp]  view plain copy

1. //最大团问题 回溯法求解  
2. #include "stdafx.h"  
3. #include <iostream>  
4. #include <fstream>  
5. using namespace std;  
6.   
7. const int N = 5;//图G的顶点数  
8. ifstream fin("5d7.txt");     
9.   
10. class Clique  
11. {  
12.     friend int MaxClique(int **,int[],int);  
13.     private:  
14.         void Backtrack(int i);  
15.         int **a,        //图G的邻接矩阵  
16.             n,          //图G的顶点数  
17.             *x,         //当前解  
18.             *bestx,     //当前最优解  
19.             cn,         //当前顶点数  
20.             bestn;      //当前最大顶点数  
21. };  
22.   
23. int MaxClique(int **a, int v[], int n);  
24.   
25. int main()  
26. {  
27.     int v[N+1];  
28.     int **a = new int *[N+1];    
29.     for(int i=1;i<=N;i++)      
30.     {      
31.         a[i] = new int[N+1];      
32.     }   
33.       
34.     cout<<"图G的邻接矩阵为:"<<endl;  
35.     for(int i=1; i<=N; i++)    
36.     {    
37.         for(int j=1; j<=N; j++)    
38.         {    
39.             fin>>a[i][j];        
40.             cout<<a[i][j]<<" ";      
41.         }    
42.         cout<<endl;    
43.     }  
44.   
45.     cout<<"图G的最大团解向量为："<<endl;  
46.     cout<<"图G的最大团顶点个数为："<<MaxClique(a,v,N)<<endl;  
47.   
48.     for(int i=1;i<=N;i++)      
49.     {      
50.         delete[] a[i];     
51.     }   
52.     delete []a;  
53.     return 0;  
54. }  
55.   
56. // 计算最大团  
57. void Clique::Backtrack(int i)  
58. {  
59.     if (i > n) // 到达叶结点  
60.     {  
61.         for (int j = 1; j <= n; j++)  
62.         {  
63.             bestx[j] = x[j];  
64.             cout<<x[j]<<" ";  
65.         }  
66.         cout<<endl;  
67.         bestn = cn;  
68.         return;  
69.     }  
70.     // 检查顶点 i 与当前团的连接  
71.     int OK = 1;  
72.     for (int j = 1; j < i; j++)  
73.     if (x[j] && a[i][j] == 0)  
74.     {  
75.         // i与j不相连  
76.         OK = 0;  
77.         break;  
78.     }  
79.   
80.     if (OK)// 进入左子树  
81.     {  
82.         x[i] = 1;  
83.         cn++;  
84.         Backtrack(i+1);  
85.         x[i] = 0;  
86.         cn--;  
87.     }  
88.   
89.     if (cn + n - i >= bestn)// 进入右子树  
90.     {  
91.         x[i] = 0;  
92.         Backtrack(i+1);  
93.     }  
94. }  
95.   
96. int MaxClique(int **a, int v[], int n)  
97. {  
98.     Clique Y;  
99.   
100.     //初始化Y  
101.     Y.x = new int[n+1];  
102.     Y.a = a;  
103.     Y.n = n;  
104.     Y.cn = 0;  
105.     Y.bestn = 0;  
106.     Y.bestx = v;  
107.     Y.Backtrack(1);  
108.     delete[] Y.x;  
109.     return Y.bestn;  
110. }  

     程序运行结果如图：

     2、图的m着色问题

     问题描述

       给定无向连通图G和m种不同的颜色。用这些颜色为图G的各顶点着色，每个顶点着一种颜色。是否有一种着色法使G中每条边的2个顶点着不同颜色。这个问题是图的m可着色判定问题。若一个图最少需要m种颜色才能使图中每条边连接的2个顶点着不同颜色，则称这个数m为该图的色数。求一个图的色数m的问题称为图的m可着色优化问题。

     四色猜想：四色问题是m图着色问题的一个特例，根据四色原理，证明平面或球面上的任何地图的所有区域都至多可用四种、颜色来着色，并使任何两个有一段公共边界的相邻区域没有相同的颜色。这个问题可转换成对一平面图的４－着色判定问题(平面图是一个能画于平面上而边无任何交叉的图)。将地图的每个区域变成一个结点，若两个区域相邻，则相应的结点用一条边连接起来。多年来，虽然已证明用5种颜色足以对任一幅地图着色，但是一直找不到一定要求多于4种颜色的地图。直到1976年这个问题才由爱普尔，黑肯和考西利用电子计算机的帮助得以解决。他们证明了4种颜色足以对任何地图着色。

     算法设计

     考虑所有的图，讨论在至多使用m种颜色的情况下，可对一给定的图着色的所有不同方法。通过回溯的方法，不断的为每一个节点着色，在前面n-1个节点都合法的着色之后，开始对第n个节点进行着色，这时候枚举可用的m个颜色，通过和第n个节点相邻的节点的颜色，来判断这个颜色是否合法，如果找到那么一种颜色使得第n个节点能够着色，那么说明m种颜色的方案是可行的。

     用m种颜色为无向图G=(V,E)着色，其中，V的顶点个数为n，可以用一个n元组x=(x1,x2,…,xn)来描述图的一种可能着色，其中，xi∈{1, 2, …, m}，(1≤i≤n)表示赋予顶点i的颜色。例如，5元组(1, 2, 2, 3, 1)表示对具有5个顶点的无向图（a）的一种着色，顶点A着颜色1，顶点B着颜色2，顶点C着颜色2，如此等等。如果在n元组X中，所有相邻顶点都不会着相同颜色，就称此n元组为可行解，否则为无效解。容易看出，每个顶点可着颜色有m种选择，n个顶点就有mn种不同的着色方案，问题的解空间是一棵高度为n的完全m叉树，这里树高度的定义为从根节点到叶子节点的路径的长度。每个分支结点，都有m个儿子结点。最底层有mn个叶子结点。例如，表示用3种颜色为3个顶点的图着色的状态空间树。如图所示，对第i（i>=1）层上的每个顶点，从其父节点到该节点的边上的标号表示顶点i着色的颜色编号。

    算法具体实现代码如下：

[cpp]  view plain copy

1. //图的着色问题 回溯法求解  
2. #include "stdafx.h"  
3. #include <iostream>  
4. #include <fstream>  
5. using namespace std;  
6.   
7. const int N = 5;//图的顶点数  
8. const int M = 3;//色彩数  
9. ifstream fin("5d8.txt");   
10.   
11. class Color  
12. {  
13.     friend int mColoring(int, int, int **);  
14.     private:  
15.         bool Ok(int k);  
16.         void Backtrack(int t);  
17.         int n,      //图的顶点数  
18.             m,      //可用的颜色数  
19.             **a,    //图的邻接矩阵  
20.             *x;     //当前解  
21.         long sum;   //当前已找到的可m着色方案数  
22. };  
23.   
24. int mColoring(int n,int m,int **a);  
25.   
26. int main()  
27. {  
28.     int **a = new int *[N+1];    
29.     for(int i=1;i<=N;i++)      
30.     {      
31.         a[i] = new int[N+1];      
32.     }   
33.       
34.     cout<<"图G的邻接矩阵为:"<<endl;  
35.     for(int i=1; i<=N; i++)    
36.     {    
37.         for(int j=1; j<=N; j++)    
38.         {    
39.             fin>>a[i][j];        
40.             cout<<a[i][j]<<" ";      
41.         }    
42.         cout<<endl;    
43.     }  
44.     cout<<"图G的着色方案如下："<<endl;  
45.     cout<<"当m="<<M<<"时，图G的可行着色方案数目为："<<mColoring(N,M,a)<<endl;  
46.     for(int i=1;i<=N;i++)      
47.     {      
48.         delete[] a[i];     
49.     }   
50.     delete []a;  
51. }  
52.   
53. void Color::Backtrack(int t)  
54. {  
55.     if (t>n)  
56.     {  
57.         sum++;  
58.         for (int i=1; i<=n; i++)  
59.         cout << x[i] << " ";  
60.         cout << endl;  
61.     }  
62.     else  
63.     {  
64.         for (int i=1;i<=m;i++) {  
65.             x[t]=i;  
66.             if (Ok(t)) Backtrack(t+1);  
67.         }  
68.     }  
69. }  
70.   
71. bool Color::Ok(int k)// 检查颜色可用性  
72. {  
73.     for (int j=1;j<=n;j++)  
74.     {  
75.         if ((a[k][j]==1)&&(x[j]==x[k])) //相邻且颜色相同  
76.         {  
77.             return false;  
78.         }  
79.     }  
80.     return true;  
81. }  
82.   
83. int mColoring(int n,int m,int **a)  
84. {  
85.     Color X;  
86.   
87.     //初始化X  
88.     X.n = n;  
89.     X.m = m;  
90.     X.a = a;  
91.     X.sum = 0;  
92.     int *p = new int[n+1];  
93.     for(int i=0; i<=n; i++)  
94.     {  
95.         p[i] = 0;  
96.     }  
97.     X.x = p;  
98.     X.Backtrack(1);  
99.     delete []p;  
100.     return X.sum;  
101. }  

     图m可着色问题的解空间树中内结点个数是。对于每一个内结点，在最坏情况下，用ok检查当前扩展结点的每一个儿子所相应的颜色可用性需耗时O(mn)。因此，回溯法总的时间耗费是。程序运行结果如图：