回溯法小实例

1、图的m着色问题：

/*
*问题描述：给定无向连通图G和m种不同的颜色。用这些颜色为图G的各个顶点着色，每个顶点着一种颜色。是否有一种着色法使G中每条边的两个顶点着不同的颜色。
*           这个问题是图的m可着色判定问题。若一个图最少需要m中颜色才能使图中每条边连接的2个顶点着不同的颜色，则称这个数m为该图的色数。
*算法分析：给定图G=(V,E)和m中颜色，如果这个图不是m可着色，给出否定回答；如果这个图是m可着色的，找出所有不同的着色法。
*           回溯法+子集树
*           问题的解空间可表示为一棵高度为n+1的完全m叉树，解空间树的第i层中每一个结点都有m个儿子，每个儿子相应于x[i]的m个可能的着色之一，第n+1层结点均为叶结点。        
*算法效率：图m可着色问题的解空间树中的内结点个数是m^i之和（i从0到n-1），在最坏的情况下，用ok检查当前扩展结点的每一个儿子所相应的颜色的可用性需耗时O(mn)。
           因此回溯总的耗时为mn(m^n-1)/(m-1)=O(nm^n)
*附    注：初始化无向图矩阵的时候对角线赋值为0！！！ 
*Author：xymaqingxiang
*Time：2014--5-22
*/

#include <fstream>
#include <iostream>
#include <stdlib.h>
#include <conio.h>
using namespace std;

#define MAX_v 50 //定义一个最大顶点个数
typedef struct{
    int a[MAX_v][MAX_v]; //无向图G的邻接矩阵
    int n; //无向图G的顶点数
    int m; //无向图G的颜色数
    int x[50]; //当前解
    long sum;//当前已找到的可m着色的方案数
}MC;

void Creat(MC &G);
void Backtrack(MC &G,int t);

void Creat(MC &G){
    int i,j;
    ifstream fin("data.txt");
    if (!fin)
    {
        cout<<"不能打开文件:"<<"data.txt"<<endl;
        exit(1);
    }
    fin>>G.n;
    fin>>G.m;
    for (int i=1;i<=G.n;i++)
        for (int j=1;j<=G.n;j++)
            fin>>G.a[i][j];
    for(i=1;i<=G.n;i++) //初始化
    {
        G.x[i]=0;
        G.sum=0;
    }
    cout<<"———回溯法求解图的m着色问题———"<<endl;
    cout<<"输入初始化无向图矩阵为:"<<endl; //初始化
    for(i=1;i<=G.n;i++)
    {
        for(j=1;j<=G.n;j++)
            cout<<G.a[i][j]<<" ";
        cout<<endl;
    }
    cout<<"输入初始化无向图顶点数为:"<<" "; //初始化
    cout<<G.n<<endl;
    cout<<"输入初始化无向图着色数为:"<<" "; //初始化
    cout<<G.m<<endl;
}

bool ok(MC &G,int k)
{
    for(int j=1;j<=G.n;j++)
        if(G.a[k][j]==1&&G.x[j]==G.x[k])    //先后顺序——先判断是否相邻，然后判断颜色是否相同
            return false;
    return true;
}

void Backtrack(MC &G,int t){
    if (t>G.n){        //output()阶段
        G.sum++;
        for (int j=1; j<=G.n; j++)
            cout<<G.x[j]<<' ';
        cout<<endl;
    }
    else
    {
        for(int i=1;i<=G.m;i++)
        {
            G.x[t]=i;
            if(ok(G,t))
                Backtrack(G,t+1);
            G.x[t]=0;    //递归回退时返回上一层，着色赋初值0
        }
    }
}

int main(){
    MC G;
    Creat(G);
    Backtrack(G,1);
    getch();
}

2、电路板排列问题：

/*
问题描述：将n块电路板以最佳排列方式插入带有n个插槽的机箱中。n块电路板的不同排列方式对应于不同的电路板插入方案。
          设B={1, 2, …, n}是n块电路板的集合，L={N1, N2, …, Nm}是连接这n块电路板中若干电路板的m个连接块。Ni是B的一个子集，且Ni中的电路板用同一条导线连接在一起。
          设x表示n块电路板的一个排列，即在机箱的第i个插槽中插入的电路板编号是x[i]。x所确定的电路板排列Density (x)密度定义为跨越相邻电路板插槽的最大连线数。
          在设计机箱时，插槽一侧的布线间隙由电路板的排列的密度确定。因此，电路板排列问题要求对于给定的电路板连接条件(连接块)，确定电路板的最佳排列，使其具有最小密度。

算法设计：电路板排列问题是NP难问题，因此不大可能找到解此问题的多项式时间算法。考虑采用回溯法系统的搜索问题解空间的排列树，找出电路板的最佳排列。设用数组B表示输入。
          B[i][j]的值为1当且仅当电路板i在连接块Nj中。设total[j]是连接块Nj中的电路板数。对于电路板的部分排列x[1:i]，设now[j]是x[1:i]中所包含的Nj中的电路板数。
          由此可知，连接块Nj的连线跨越插槽i和i+1当且仅当now[j]>0且now[j]！=total[j]。用这个条件来计算插槽i和i+1间的连线密度。

          在算法Backtrack中，当i=n时，所有n个电路板都已排定，其密度是cd。由于算法仅完成那些比当前最优解更好的排列，故cd肯定优于bestd，此时应更新bestd。
          当i<n时，电路板排列尚未完成。x[1:i-1]是当前扩展点所相应的部分排列，cd是相应的部分排列的密度。在当前部分排列之后加入一块未排定的电路板，扩展当前部分排列产生当前扩展结点的一个儿子结点。
          对于这个儿子结点，计算新的部分排列密度ld。仅当ld<bestd时，算法搜索相应子树，否则该子树剪去。

算法效率：在解空间排列树的每个节点处，算法Backtrack花费O(m)计算时间为每个儿子节点计算密度。因此计算密度所消耗的总计算时间为O(mn!)。
          另外，生成排列树需要O(n!)时间。每次更新当前最优解至少使bestd减少1，而算法运行结束时bestd>=0。因此最优解被更新的额次数为O(m)。更新最优解需要O(mn)时间。
          综上，解电路板排列问题的回溯算法Backtrack所需要的计算时间为O(mn!)。

Auther：xymaqingxiang
Time：2014-05-23
*/

//#include "stdafx.h"
#include <iostream>
#include <fstream> 
#include <stdlib.h>
#include <conio.h>
using namespace std;

int k=0;

class Board
{
    friend int Arrangement(int **B, int n, int m, int bestx[]);
    private:
        void Backtrack(int i,int cd);
        int n,        //电路板数
            m,        //连接板数
            *x,        //当前解
            *bestx,//当前最优解
            bestd,  //当前最优密度
            *total, //total[j]=连接块j的电路板数
            *now,   //now[j]=当前解中所含连接块j的电路板数
            **B;    //连接块数组
};

template <class Type>
inline void Swap(Type &a, Type &b);

int Arrangement(int **B, int n, int m, int bestx[]);

int main()
{
    int m ,n;
    int bestx[9];

    ifstream fin("data.txt"); 

    fin>>m;
    fin>>n;
    cout<<"m="<<m<<",n="<<n<<endl;
    cout<<"N1={4,5,6},N2={2,3},N3={1,3},N4={3,6},N5={7,8}"<<endl;
    cout<<"二维数组B如下："<<endl;
    
    //构造B
    int **B = new int*[n+1];
    for(int i=1; i<=n; i++)
        B[i] = new int[m+1];

    for(int i=1; i<=n; i++)
    {
        for(int j=1; j<=m ;j++)
        {
            fin>>B[i][j];
            cout<<B[i][j]<<" ";
        }
        cout<<endl;
    }

    //第一种方案——只打印其中一种最优的电路排列
    //cout<<"返回的其中一种最优解:"<<endl;
    //cout<<"当前最优密度为:"<<Arrangement(B,n,m,bestx)<<endl;
    //cout<<"最优排列为："<<endl;
    //for(int i=1; i<=n; i++)
        //cout<<bestx[i]<<" ";
    //cout<<endl;

    //第二种方案——打印出所有的最优电路排列
    Arrangement(B,n,m,bestx);

    for(int i=1; i<=n; i++)
        delete[] B[i];
    delete[] B;

    cout<<"总方案数为："<<k<<endl;
    getch();

    return 0;
}

void Board::Backtrack(int i,int cd)//回溯法搜索排列树
{
    
    if(i == n)
    {
        cout<<endl;
        k++;
        cout<<"第"<<k<<"种最优密度为：";
        cout<<cd<<endl;
        cout<<"最优电路排列为：";
        for(int i=1; i<=n; i++)
            cout<<x[i]<<" ";
        cout<<endl;
        cout<<endl;

        for(int j=1; j<=n; j++)
            bestx[j] = x[j];
        bestd = cd;
    }
    else
    {
        for(int j=i; j<=n; j++)
        {
            //选择x[j]为下一块电路板
            int ld = 0;
            for(int k=1; k<=m; k++)
            {
                now[k] += B[x[j]][k];
                if(now[k]>0 && total[k]!=now[k])
                    ld ++;
            }

            //更新ld
            if(cd>ld)
                ld = cd;

            if(ld<=bestd)//搜索子树————剪枝函数（ld<bestd时只打印其中一种最优排列；ld<=bestd可以打印出所有的最优排列）
            {
                Swap(x[i],x[j]);
                Backtrack(i+1,ld);
                Swap(x[i],x[j]);

                //恢复状态
                for(int k=1; k<=m; k++)
                    now[k] -= B[x[j]][k];
            }
        }
    }    
}

int Arrangement(int **B, int n, int m, int bestx[])
{
    Board X;

    //初始化X
    X.x = new int[n+1];
    X.total = new int[m+1];
    X.now = new int[m+1];
    X.B = B;
    X.n = n;
    X.m = m;
    X.bestx = bestx;
    X.bestd = m+1;

    //初始化total和now
    for(int i=1; i<=m; i++)
    {
        X.total[i] = 0;
        X.now[i] = 0;
    }

    //初始化x为单位排列并计算total
    for(int i=1; i<=n; i++)
    {
        X.x[i] = i;
        for(int j=1; j<=m; j++)
        {
            X.total[j] += B[i][j];
        }
    }

    //回溯搜索
    X.Backtrack(1,0);
    delete []X.x;
    delete []X.total;
    delete []X.now;
    return X.bestd;
}

template <class Type>
inline void Swap(Type &a, Type &b)
{  
    Type temp=a; 
    a=b; 
    b=temp;
}

3、旅行售货员问题：

template<class Type>
class Traveling
{
    friend Type TSP(int **,int [],int,Type);
    friend void main(void);
public:
    Type BBTSP(int v[]);
private:
    void Backtrack(int i);
    int n,               //图G的顶点数
        *x,              //当前解
        *bestx;          //当前最优解
    Type **a,            //图G的邻接矩阵
         cc,             //当前费用
         bestc,          //当前最优值
         NoEdge;         //无边标记
};

template<class Type>
void Traveling<Type>::Backtrack(int i)
{
    if(i==n)
    {
        if(a[x[n-1]][x[n]]!=NoEdge&&a[x[n][1]!=NoEdge&&
            cc+a[x[n-1]][x[n]]+a[x[n]][1]<bestc||bestc==NoEdge))
            for(int j=1;j<=n;j++)
                bestx[j]=x[j];
        bestc=cc+a[x[n-1]][x[n]]+a[x[n]][1];
    }
    else
    {//是否进入左子树？
        for(int j=i;j<=n;j++)
            if(a[x[i-1][x[j]]!=NoEdge&&
                (cc+a[x[i-1][x[j]]<bestc||bestc==NoEdge))
            {
                //搜索子树
                Swap(x[i],x[j]);
                cc+=a[x[i-1][x[i]];
                Backtrack(i+1);
                cc-=a[x[i-1]][x[i]];
                Swap(x[i],x[j]);
            }
    }
}

template<class Type>
Type TSP(Type **a,int v[],int n,Type NoEdge)
{
    Traveling<Type> Y;
    //初始化Y
    Y.x=new int[n+1];
    //置x为单位排列
    for(int i=1;i<=n;i++)
        Y.x[i]=i;
    Y.a=a;
    Y.n=n;
    Y.bestc=NoEdge;
    Y.bestx=v;
    Y.cc=0;
    Y.NoEdge=NoEdge;
    //搜索x[2:n]的全排列
    Y.Backtrack(2);
    delete []Y.x;
    return Y.bestc;
}