【算法知识总结】回溯法

其他 2018-05-29 00:38:41 阅读次数: 0

概述

回溯法思路的简单描述是：
把问题的解空间转化成了图或者树的结构表示，然后使用深度优先搜索策略进行遍历，遍历的过程中记录和寻找所有可行解或者最优解。
基本思想类同于：

  • 图的深度优先搜索
  • 二叉树后序遍历（ 分支限界法：广度优先搜索， 思想类同于：图的广度优先遍历 二叉树的层序遍历）

详细描述

详细的描述则为：
回溯法按深度优先策略搜索问题的解空间树。

  • 首先从根节点出发搜索解空间树
  • 当算法搜索至解空间树的某一节点时，先利用剪枝函数判断该节点是否可行（即能得到问题的解）。如果不可行，则跳过对该节点为根的子树的搜索，逐层向其祖先节点回溯；
  • 否则，进入该子树，继续按深度优先策略搜索。
    .

回溯法的基本行为是搜索，搜索过程使用剪枝函数来为了避免无效的搜索。
剪枝函数包括两类：

  • 使用约束函数，剪去不满足约束条件的路径；

  • 使用限界函数，剪去不能得到最优解的路径。
    问题的关键在于如何定义问题的解空间，转化成树（即解空间树）。解空间树分为两种：子集树和排列树。两种在算法结构和思路上大体相同。

  • 回溯法应用 : 当问题是要求满足某种性质（约束条件）的所有解或最优解时，往往使用回溯法。它有“通用解题法”之美誉。

回溯法实现 - 递归和递推（迭代）

回溯法的实现方法有两种：递归和递推（也称迭代）。一般来说，一个问题两种方法都可以实现，只是在算法效率和设计复杂度上有区别。
【类比于图深度遍历的递归实现和非递归（递推）实现】

  • 递归
    思路简单，设计容易，但效率低，其设计范式如下：
//针对N叉树的递归回溯方法  
void backtrack (int t)
{
    if (t>n) output(x); //叶子节点，输出结果，x是可行解 
    else
    for i = 1 to k//当前节点的所有子节点
    {
        x[t]=value(i); //每个子节点的值赋值给x
        //满足约束条件和限界条件
        if (constraint(t)&&bound(t))
        backtrack(t+1);  //递归下一层
    }

}
  • 递推
    算法设计相对复杂，但效率高。
//针对N叉树的迭代回溯方法  
void iterativeBacktrack ()  
{  
    int t=1;  
    while (t>0) {  
        if(ExistSubNode(t)) //当前节点的存在子节点  
        {  
            for i = 1 to k  //遍历当前节点的所有子节点  
            {  
                x[t]=value(i);//每个子节点的值赋值给x  
                if (constraint(t)&&bound(t))//满足约束条件和限界条件   
                {  
                    //solution表示在节点t处得到了一个解  
                    if (solution(t)) output(x);//得到问题的一个可行解，输出  
                    else t++;//没有得到解，继续向下搜索  
                }  
            }  
        }  
        else //不存在子节点，返回上一层  
        {  
            t--;  
        }  
    }  
}

子集树和排列树

  1. 子集树

    所给的问题是从n个元素的集合S中找出满足某种性质的子集时，相应的解空间成为子集树。
    如0-1背包问题，从所给重量、价值不同的物品中挑选几个物品放入背包，使得在满足背包不超重的情况下，背包内物品价值最大。它的解空间就是一个典型的子集树。
    回溯法搜索子集树的算法范式如下：

void backtrack (int t)  
{  
  if (t>n) output(x);  
    else  
      for (int i=0;i<=1;i++) {  
        x[t]=i;  
        if (constraint(t)&&bound(t)) backtrack(t+1);  
      }  
}
  1. 排列树

所给的问题是确定n个元素满足某种性质的排列时，相应的解空间就是排列树。
如旅行售货员问题，一个售货员把几个城市旅行一遍，要求走的路程最小。它的解就是几个城市的排列，解空间就是排列树。
回溯法搜索排列树的算法范式如下：

void backtrack (int t)  
{  
  if (t>n) output(x);  
    else  
      for (int i=t;i<=n;i++) {  
        swap(x[t], x[i]);  
        if (constraint(t)&&bound(t)) backtrack(t+1);  
        swap(x[t], x[i]);  
      }  
}

经典问题

（1）装载问题
（2）0-1背包问题
（3）旅行售货员问题
（4）八皇后问题
（5）迷宫问题
（6）图的m着色问题

  • 0-1背包问题

问题：
给定n种物品和一背包。物品i的重量是wi，其价值为pi，背包的容量为C。问应如何选择装入背包的物品，使得装入背包中物品的总价值最大?
分析：
问题是n个物品中选择部分物品，可知，问题的解空间是子集树。比如物品数目n=3时，其解空间树如下图，边为1代表选择该物品，边为0代表不选择该物品。使用x[i]表示物品i是否放入背包，x[i]=0表示不放，x[i]=1表示放入。回溯搜索过程，如果来到了叶子节点，表示一条搜索路径结束，如果该路径上存在更优的解，则保存下来。如果不是叶子节点，是中点的节点（如B），就遍历其子节点（D和E），如果子节点满足剪枝条件，就继续回溯搜索子节点。
这里写图片描述

代码：

#include <stdio.h>  

#define N 3         //物品的数量  
#define C 16        //背包的容量  

int w[N]={10,8,5};  //每个物品的重量  
int v[N]={5,4,1};   //每个物品的价值  
int x[N]={0,0,0};   //x[i]=1代表物品i放入背包，0代表不放入  

int CurWeight = 0;  //当前放入背包的物品总重量  
int CurValue = 0;   //当前放入背包的物品总价值  

int BestValue = 0;  //最优值；当前的最大价值，初始化为0  
int BestX[N];       //最优解；BestX[i]=1代表物品i放入背包，0代表不放入  

//t = 0 to N-1  
void backtrack(int t)  
{  
    //叶子节点，输出结果  
    if(t>N-1)   
    {  
        //如果找到了一个更优的解  
        if(CurValue>BestValue)  
        {  
            //保存更优的值和解  
            BestValue = CurValue;  
            for(int i=0;i<N;++i) BestX[i] = x[i];  
        }  
    }  
    else  
    {  
        //遍历当前节点的子节点：0 不放入背包，1放入背包  
        for(int i=0;i<=1;++i)  
        {  
            x[t]=i;  

            if(i==0) //不放入背包  
            {  
                backtrack(t+1);  
            }  
            else //放入背包  
            {  
 <span style="white-space:pre;">                </span>//约束条件：放的下  
                if((CurWeight+w[t])<=C)  
                {  
<span style="white-space:pre;">                 </span>CurWeight += w[t];  
                    CurValue += v[t];  
                    backtrack(t+1);  
                    CurWeight -= w[t];  
                    CurValue -= v[t];  
                }  
            }  
        }  
        //PS:上述代码为了更符合递归回溯的范式，并不够简洁  
    }  
}  

int main(int argc, char* argv[])  
{  
    backtrack(0);  

    printf("最优值：%d\n",BestValue);  

    for(int i=0;i<N;i++)  
    {  
       printf("最优解：%-3d",BestX[i]);  
    }  
    return 0;  
}
  • 旅行售货员问题
    问题:
    某售货员要到若干城市去推销商品，已知各城市之间的路程(或旅费)。他要选定一条从驻地出发，经过每个城市一次，最后回到驻地的路线，使总的路程(或总旅费)最小。
    如下图：1，2，3，4 四个城市及其路线费用图，任意两个城市之间不一定都有路可达。
    这里写图片描述

问题理解
1. 分支限界法利用的是广度优先搜索和最优值策略。
2. 利用二维数组保存图信息City_Graph[MAX_SIZE][MAX_SIZE]
其中City_Graph[i][j]的值代表的是城市i与城市j之间的路径费用
一旦一个城市没有通向另外城市的路，则不可能有回路，不用再找下去了
3. 我们任意选择一个城市，作为出发点。（因为最后都是一个回路，无所谓从哪出发）

下面是关键思路：
想象一下，我们就是旅行员，假定从城市1出发，根据广度优先搜索的思路，我们要把从城市1能到达的下一个城市，都要作为一种路径走一下试试。
可是程序里面怎么实现这种“试试”呢？
利用一种数据结构，保存我们每走一步后，当前的一些状态参数，如，我们已经走过的城市数目（这样就知道，我们有没有走完，比如上图，当我们走了四个城市之后，无论从第四个城市是否能回到起点城市，都就意味着我们走完了，只是这条路径合不合约束以及能不能得到最优解的问题）。这里把，这种数据结构成为结点。这就需要另一个数据结构，保存我们每次试出来的路径，这就是堆。

  • a. 我们刚开始的时候不知道最总能得到的路径是什么，所以我们，就认为按照城市编号的次序走一遍。于是有了第一个结点0，放入堆中。 相当于来到了城市1(可以是所有城市中的任意一个，这里姑且设为图中城市1)。
  • b.从城市1，出发，发现有三条路可走，分别走一下，这样就产生了三个结点，都放入堆中。
    结点1 数据为：x[1 2 3 4]，深度为s=1（深度为0表示在城市1还没有开始走），这说明，结点1是从城市1走来，走过了1个城 市，当前停在城市2，后面的城市3 和城市4都还没有走，但是具体是不是就按照3.4的顺序走，这个不一定。
    结点2 数据为：x[1 3 2 4]，深度为s=1，表示，从城市1走来，走过了1个城市，当前停在了城市3，后面2.4城市还没走
    结点3 数据为：x[1 4 3 2]，深度为s=1，表示，从城市1走来，走过了1个城市，当前停在了城市4，后面3.2城市还没有走
  • c. 从堆中取一个结点，看看这个结点是不是走完了的，也就是要看看它的深度是不是3，是的话，说明走完了，看看是不是能回到起 点，如果可以而且费用少于先前得到最优的费用，就把当前的解作为最优解。
    如果没有走完，就继续把这条路走下去。

以上就是简单的想法，而实际的程序中，堆还需要提供对结点的优先权排序的支持。而当前结点在往下一个城市走时，也是需要约束和限界函数，这些书上讲的很清楚，不懂，就翻翻书。
有点要提出来说说的就是结点优先权和限界函数时都用到了一个最小出边和，就相当于把所有城市最便宜的一条路（边）费用加起来的值。

代码：

#include <stdio.h>  
#include <istream>  
using namespace std;  
//---------------------宏定义------------------------------------------  
#define MAX_CITY_NUMBER 10          //城市最大数目  
#define MAX_COST 10000000           //两个城市之间费用的最大值  
//---------------------全局变量----------------------------------------  
int City_Graph[MAX_CITY_NUMBER][MAX_CITY_NUMBER];  
                            //表示城市间边权重的数组  
int City_Size;              //表示实际输入的城市数目  
int Best_Cost;              //最小费用  
int Best_Cost_Path[MAX_CITY_NUMBER];  
                            //最小费用时的路径    
//------------------------定义结点---------------------------------------  
typedef struct Node{  
    int lcost;              //优先级  
    int cc;                 //当前费用  
    int rcost;              //剩余所有结点的最小出边费用的和  
    int s;                  //当前结点的深度，也就是它在解数组中的索引位置  
    int x[MAX_CITY_NUMBER]; //当前结点对应的路径  
    struct Node* pNext;     //指向下一个结点  
}Node;  
//---------------------定义堆和相关对操作--------------------------------  
typedef struct MiniHeap{  
    Node* pHead;             //堆的头  
}MiniHeap;  
//初始化  
void InitMiniHeap(MiniHeap* pMiniHeap){  
    pMiniHeap->pHead = new Node;  
    pMiniHeap->pHead->pNext = NULL;  
}  
//入堆  
void put(MiniHeap* pMiniHeap,Node node){  
    Node* next;  
    Node* pre;   
    Node* pinnode = new Node;         //将传进来的结点信息copy一份保存  
                                      //这样在函数外部对node的修改就不会影响到堆了  
    pinnode->cc = node.cc;  
    pinnode->lcost = node.lcost;  
    pinnode->pNext = node.pNext;  
    pinnode->rcost = node.rcost;  
    pinnode->s = node.s;  
    pinnode->pNext = NULL;  
    for(int k=0;k<City_Size;k++){  
        pinnode->x[k] = node.x[k];  
    }  
    pre = pMiniHeap->pHead;  
    next = pMiniHeap->pHead->pNext;  
    if(next == NULL){  
        pMiniHeap->pHead->pNext = pinnode;  
    }  
    else{  
        while(next != NULL){  
            if((next->lcost) > (pinnode->lcost)){ //发现一个优先级大的，则置于其前面  
                pinnode->pNext = pre->pNext;  
                pre->pNext = pinnode;  
                break;                            //跳出  
            }  
            pre = next;  
            next = next->pNext;  
        }  
        pre->pNext = pinnode;                           //放在末尾  
    }     
}  
//出堆  
Node* RemoveMiniHeap(MiniHeap* pMiniHeap){  
    Node* pnode = NULL;  
    if(pMiniHeap->pHead->pNext != NULL){  
        pnode = pMiniHeap->pHead->pNext;  
        pMiniHeap->pHead->pNext = pMiniHeap->pHead->pNext->pNext;  
    }  
    return pnode;  
}  
//---------------------分支限界法找最优解--------------------------------  
void Traveler(){  
    int i,j;  
    int temp_x[MAX_CITY_NUMBER];  
    Node* pNode = NULL;  
    int miniSum;                    //所有结点最小出边的费用和  
    int miniOut[MAX_CITY_NUMBER];  
                                    //保存每个结点的最小出边的索引  
    MiniHeap* heap = new MiniHeap;  //分配堆  
    InitMiniHeap(heap);             //初始化堆  

    miniSum = 0;  
    for (i=0;i<City_Size;i++){  
        miniOut[i] = MAX_COST;      //初始化时每一个结点都不可达  
        for(j=0;j<City_Size;j++){  
            if (City_Graph[i][j]>0 && City_Graph[i][j]<miniOut[i]){  
                                    //从i到j可达，且更小  
                miniOut[i] = City_Graph[i][j];  
            }  
        }  
        if (miniOut[i] == MAX_COST){// i 城市没有出边  
            Best_Cost = -1;  
            return ;  
        }  
        miniSum += miniOut[i];     
    }  
    for(i=0;i<City_Size;i++){       //初始化的最优路径就是把所有结点依次走一遍  
        Best_Cost_Path[i] = i;  
    }  
    Best_Cost = MAX_COST;           //初始化的最优费用是一个很大的数  
    pNode = new Node;               //初始化第一个结点并入堆  
    pNode->lcost = 0;               //当前结点的优先权为0 也就是最优  
    pNode->cc = 0;                  //当前费用为0（还没有开始旅行）  
    pNode->rcost = miniSum;         //剩余所有结点的最小出边费用和就是初始化的miniSum  
    pNode->s = 0;                   //层次为0  
    pNode->pNext = NULL;  
    for(int k=0;k<City_Size;k++){  
        pNode->x[k] = Best_Cost_Path[k];      //第一个结点所保存的路径也就是初始化的路径  
    }  
    put(heap,*pNode);               //入堆  
    while(pNode != NULL && (pNode->s) < City_Size-1){  
                                    //堆不空 不是叶子  
        for(int k=0;k<City_Size;k++){  
            Best_Cost_Path[k] = pNode->x[k] ;      //将最优路径置换为当前结点本身所保存的  
        }  
/* 
* *  pNode 结点保存的路径中的含有这条路径上所有结点的索引 
* *  x路径中保存的这一层结点的编号就是x[City_Size-2] 
* *  下一层结点的编号就是x[City_Size-1] 
*/  
        if ((pNode->s) == City_Size-2){ //是叶子的父亲  
            int edge1 = City_Graph[(pNode->x)[City_Size-2]][(pNode->x)[City_Size-1]];  
            int edge2 = City_Graph[(pNode->x)[City_Size-1]][(pNode->x)[0]];  
            if(edge1 >= 0 && edge2 >= 0 &&  (pNode->cc+edge1+edge2) < Best_Cost){  
                                                                             //edge1 -1 表示不可达  
                                                                             //叶子可达起点费用更低  
                   Best_Cost = pNode->cc + edge1+edge2;  
                   pNode->cc = Best_Cost;  
                   pNode->lcost = Best_Cost;                                  //优先权为 Best_Cost  
                   pNode->s++;                                                 //到达叶子层  
            }  
        }  
        else{                                                                 //内部结点  
            for (i=pNode->s;i<City_Size;i++){                                 //从当前层到叶子层  
                if(City_Graph[pNode->x[pNode->s]][pNode->x[i]] >= 0){   //可达  
                                    //pNode的层数就是它在最优路径中的位置  
                    int temp_cc = pNode->cc+City_Graph[pNode->x[pNode->s]][pNode->x[i]];  
                    int temp_rcost = pNode->rcost-miniOut[pNode->x[pNode->s]];  
                                                            //下一个结点的剩余最小出边费用和   
                                                            //等于当前结点的rcost减去当前这个结点的最小出边费用  
                    if (temp_cc+temp_rcost<Best_Cost){      //下一个结点的最小出边费用和小于当前的最优解，说明可能存在更优解  
                        for (j=0;j<City_Size;j++){           //完全copy路径，以便下面修改  
                            temp_x[j]=Best_Cost_Path[j];  
                        }  
                        temp_x[pNode->x[pNode->s+1]] = Best_Cost_Path[i];  
                                                            //将当前结点的编号放入路径的深度为s+1的地方  
                        temp_x[i] = Best_Cost_Path[pNode->s+1]; //??????????????  
                                                            //将原路//径中的深度为s+1的结点编号放入当前路径的  
                                                            //相当于将原路径中的的深度为i的结点与深度W为s+1的结点交换  
                        Node* pNextNode = new Node;  
                        pNextNode->cc = temp_cc;  
                        pNextNode->lcost = temp_cc+temp_rcost;  
                        pNextNode->rcost = temp_rcost;  
                        pNextNode->s = pNode->s+1;  
                        pNextNode->pNext = NULL;  
                        for(int k=0;k<City_Size;k++){  
                            pNextNode->x[k] = temp_x[k];  
                        }  
                        put(heap,*pNextNode);  
                        delete pNextNode;  
                    }  
                }  
            }  
        }  
        pNode = RemoveMiniHeap(heap);  
    }  
}  
int main(){  
    int i,j;  
    scanf("%d",&City_Size);  
    for(i=0;i<City_Size;i++){  
        for(j=0;j<City_Size;j++){  
            scanf("%d",&City_Graph[i][j]);  
        }  
    }  
    Traveler();  
    printf("%d/n",Best_Cost);  
    return 1;  
}
  • N皇后问题
    问题：
    在n×n格的棋盘上放置彼此不受攻击的n个皇后。按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。
    N皇后问题等价于在n×n格的棋盘上放置n个皇后，任何2个皇后不放在同一行或同一列或同一斜线上。
    分析：
    从n×n个格子中选择n个格子摆放皇后。可见解空间树为子集树。
    使用Board[N][N]来表示棋盘，Board[i][j]=0 表示(i,j)位置为空，Board[i][j]=1 表示(i,j)位置摆放有一个皇后。
    全局变量way表示总共的摆放方法数目。
    使用Queen(t)来摆放第t个皇后。Queen(t) 函数符合子集树时的递归回溯范式。当t>N时，说明所有皇后都已经摆 放完成，这是一个可行的摆放方法，输出结果；否则，遍历棋盘，找皇后t所有可行的摆放位置，Feasible(i,j) 判断皇后t能否摆放在位置(i,j)处，如果可以摆放则继续递归摆放皇后t+1，如果不能摆放，则判断下一个位置。
    Feasible(row,col)函数首先判断位置(row,col)是否合法，继而判断(row,col)处是否已有皇后，有则冲突，返回0，无则继续判断行、列、斜方向是否冲突。斜方向分为左上角、左下角、右上角、右下角四个方向，每次从（row,col）向四个方向延伸一个格子，判断是否冲突。如果所有方向都没有冲突，则返回1，表示此位置可以摆放一个皇后。
    这里写图片描述
    代码：
/************************************************************************  
 * 名  称：NQueen.cpp 
 * 功  能：回溯算法实例：N皇后问题  
 * 作  者：JarvisChu  
 * 时  间：2013-11-13  
 ************************************************************************/   

#include <stdio.h>  

#define N 8  

int Board[N][N];<span style="white-space:pre;"> </span>//棋盘 0表示空白 1表示有皇后  
int way;<span style="white-space:pre;">     </span>//摆放的方法数  


//判断能否在(x,y)的位置摆放一个皇后；0不可以，1可以  
int Feasible(int row,int col)  
{  
    //位置不合法  
    if(row>N || row<0 || col >N || col<0)  
        return 0;  

    //该位置已经有皇后了，不能  
    if(Board[row][col] != 0)  
    {   //在行列冲突判断中也包含了该判断，单独提出来为了提高效率  
        return 0;  
    }  

    //////////////////////////////////////////////////  
    //下面判断是否和已有的冲突  

    //行和列是否冲突  
    for(int i=0;i<N;++i)  
    {  
        if(Board[row][i] != 0 || Board[i][col]!=0)  
            return 0;  
    }  

    //斜线方向冲突  

    for(int i=1;i<N;++i)  
    {  
/* i表示从当前点(row,col)向四个斜方向扩展的长度 

左上角 \  / 右上角   i=2 
        \/           i=1 
        /\           i=1 
左下角 /  \ 右下角   i=2 
*/  
        //左上角  
        if((row-i)>=0 && (col-i)>=0)    //位置合法  
        {  
            if(Board[row-i][col-i] != 0)//此处已有皇后，冲突  
                return 0;  
        }  

        //左下角  
        if((row+i)<N && (col-i)>=0)  
        {  
            if(Board[row+i][col-i] != 0)  
                return 0;  
        }  

        //右上角  
        if((row-i)>=0 && (col+i)<N)  
        {  
            if(Board[row-i][col+i] != 0)  
                return 0;  
        }  

        //右下角  
        if((row+i)<N && (col+i)<N)  
        {  
            if(Board[row+i][col+i] != 0)  
                return 0;  
        }  
    }  

    return 1; //不会发生冲突，返回1  
}  


//摆放第t个皇后 ；从1开始  
void Queen(int t)  
{  
    //摆放完成，输出结果  
    if(t>N)  
    {  
        way++;  
        /*如果N较大，输出结果会很慢；N较小时，可以用下面代码输出结果 
        for(int i=0;i<N;++i){ 
            for(int j=0;j<N;++j) 
                printf("%-3d",Board[i][j]); 
            printf("\n"); 
        } 
        printf("\n------------------------\n\n"); 
        */  
    }  
    else  
    {  
        for(int i=0;i<N;++i)  
        {  
            for(int j=0;j<N;++j)  
            {  
                //（i,j）位置可以摆放皇后，不冲突  
                if(Feasible(i,j))  
                {  
                    Board[i][j] = 1;  //摆放皇后t  
                    Queen(t+1);       //递归摆放皇后t+1  
                    Board[i][j] = 0;  //恢复  
                }  
            }  
        }  
    }  
}  

//返回num的阶乘,num!  
int factorial(int num)  
{  
    if(num==0 || num==1)  
        return 1;  
    return num*factorial(num-1);  
}  


int main(int argc, char* argv[])  
{  
    //初始化  
    for(int i=0;i<N;++i)  
    {  
        for(int j=0;j<N;++j)  
        {  
            Board[i][j]=0;  
        }  
    }  

    way = 0;  

    Queen(1);  //从第1个皇后开始摆放  

    //如果每个皇后都不同  
    printf("考虑每个皇后都不同，摆放方法：%d\n",way);//N=8时, way=3709440 种  

    //如果每个皇后都一样，那么需要除以 N！出去重复的答案（因为相同，则每个皇后可任意调换位置）  
    printf("考虑每个皇后都不同，摆放方法：%d\n",way/factorial(N));//N=8时, way=3709440/8! = 92种  

    return 0;  
}

PS：
该问题还有更优的解法。充分利用问题隐藏的约束条件：每个皇后必然在不同的行(列)，每个行(列)必然也只有一个皇后。这样我们就可以把N个皇后放到N个行中，使用Pos[i]表示皇后i在i行中的位置（也就是列号）（i = 0 to N-1）。这样代码会大大的简洁，因为节点的子节点数目会减少，判断冲突也更简单。

  • 迷宫问题

.
问题：
给定一个迷宫，找到从入口到出口的所有可行路径，并给出其中最短的路径
分析：
用二维数组来表示迷宫，则走迷宫问题用回溯法解决的的思想类似于图的深度遍历。从入口开始，选择下一个可以走的位置，如果位置可走，则继续往前，如果位置不可走，则返回上一个位置，重新选择另一个位置作为下一步位置。
N表示迷宫的大小，使用Maze[N][N]表示迷宫，值为0表示通道（可走），值为1表示不可走（墙或者已走过）；
Point结构体用来记录路径中每一步的坐标(x,y)
(ENTER_X,ENTER_Y) 是迷宫入口的坐标
(EXIT_X, EXIT _Y) 是迷宫出口的坐标
Path容器用来存放一条从入口到出口的通路路径
BestPath用来存放所有路径中最短的那条路径
Maze()函数用来递归走迷宫，具体步骤为：
1. 首先将当前点加入路径，并设置为已走
2. 判断当前点是否为出口，是则输出路径，保存结果；跳转到4
3. 依次判断当前点的上、下、左、右四个点是否可走，如果可走则递归走该点
4. 当前点推出路径，设置为可走
代码：

/************************************************************************  
 * 名  称：Maze.cpp 
 * 功  能：回溯算法实例：迷宫问题 
 * 作  者：JarvisChu  
 * 时  间：2013-11-13  
 ************************************************************************/   
#include <iostream>  
#include <vector>  

using namespace std;  

typedef struct  
{  
    int x;  
    int y;  
}Point;  

#define N 10         //迷宫的大小  
#define ENTER_X 0    //入口的位置（0，0）  
#define ENTER_Y 0  
#define EXIT_X N-1   //出口的位置(N-1,N-1)  
#define EXIT_Y N-1   


int Maze[N][N];<span style="white-space:pre;">      </span>//定义一个迷宫，0表示通道，1表示不可走（墙或已走）  
int paths;<span style="white-space:pre;">       </span>//路径条数  
vector<Point> Path;<span style="white-space:pre;">    </span>//保存一条可通的路径  
vector<Point> BestPath;<span style="white-space:pre;">    </span>//保存最短的路径  

bool First = true;<span style="white-space:pre;">   </span>//标志，找到第一条路径  

//初始化迷宫  
void InitMaze()  
{  
<span style="white-space:pre;"> </span>//简单起见，本题定义一个固定大小10*10的迷宫  
<span style="white-space:pre;"> </span>//定义一个迷宫，0表示通道，1表示墙(或不可走)  
    int mz[10][10]={  
    {0,0,1,1,1,1,1,1,1,1}, //0  
    {1,0,0,1,1,0,0,1,0,1}, //1  
    {1,0,0,1,0,0,0,1,0,1}, //2  
    {1,0,0,0,0,1,1,0,0,1}, //3  
    {1,0,1,1,1,0,0,0,0,1}, //4  
    {1,0,0,0,1,0,0,0,0,1}, //5  
    {1,0,1,0,0,0,1,0,0,1}, //6  
    {1,0,1,1,1,0,1,1,0,1}, //7  
    {1,1,0,0,0,0,0,0,0,0}, //8  
    {1,1,1,1,1,1,1,1,1,0}  //9  
    //   0 1 2 3 4 5 6 7 8 9  
    };   

    //复制到迷宫  
    memcpy(Maze,mz,sizeof(mz));  

    paths = 0;  
}  

//从(x,y)位置开始走；初始为(0,0)  
void MazeTrack(int x,int y)  
{  
    ///////////////////////////////////////  
    //当前点加入到路径  
    Point p={x,y};  
    Path.push_back(p);  
    Maze[x][y] = 1;         //设置为已走，不可走  

    //cout<<"来到("<<x<<","<<y<<")"<<endl;  

    ///////////////////////////////////////  
    //如果该位置是出口，输出结果  
    if(x == EXIT_X && y== EXIT_Y)  
    {  
        cout<<"找到一条道路"<<endl;  
        paths++;  

        //输出路径  
        vector<Point>::iterator it;  
        for(it=Path.begin();it!=Path.end();++it)  
        {  
            cout<<"("<<it->x<<","<<it->y<<") ";  
        }  
        cout<<endl;  

        //判断是否更优  
        if(First)//如果是找到的第一条路径，直接复制到最优路径  
        {  
            for(it=Path.begin();it!=Path.end();++it)  
            {  
                BestPath.push_back(*it);  
            }  
            First = false;  
        }  
        else //不是第一条，则判断是否更短  
        {  
            //更短，复制到最优路径  
            if(Path.size()<BestPath.size())  
            {  
                BestPath.clear();  
                for(it=Path.begin();it!=Path.end();++it)  
                {  
                    BestPath.push_back(*it);  
                }  
            }  
        }  
    }  

    ///////////////////////////////////////  
    //判断(x,y)位置的上、下、左、右是否可走  

    if((x-1)>=0 && Maze[x-1][y]==0)//上(x-1,y)；存在且可走  
    {  
        MazeTrack(x-1,y);  
    }  

    if((x+1)<N && Maze[x+1][y]==0)//下(x+1,y)；存在且可走  
    {  
        MazeTrack(x+1,y);  
    }  

    if((y-1)>=0 && Maze[x][y-1]==0)//左(x,y-1)；存在且可走  
    {  
        MazeTrack(x,y-1);  
    }  

    if((y+1)<N && Maze[x][y+1]==0)//右(x,y+1)；存在且可走  
    {  
        MazeTrack(x,y+1);  
    }  

    ///////////////////////////////////////  
    //返回上一步  
    Path.pop_back();  
    Maze[x][y] = 0;         //设置为未走  
}  


int main(int argc, char* argv[])  
{  
    //初始化迷宫  
    InitMaze();  

/*  //显示迷宫 
    for(int i=0;i<N;++i){ 
        for(int j=0;j<N;++j) 
            cout<<Maze[i][j]<<"  "; 
        cout<<endl; 
    }*/  

    //回溯法走迷宫  
    MazeTrack(ENTER_X,ENTER_Y);  

    //显示最优的路径  
    cout<<"可行路径总条数为"<<paths<<"；最优路径为"<<endl;  
    vector<Point>::iterator it;  
    for(it=BestPath.begin();it!=BestPath.end();++it)  
    {  
        cout<<"("<<it->x<<","<<it->y<<") ";  
    }  
    cout<<endl;  
    return 0;  
}

参考文献： 《计算机算法设计与分析》（王晓东）

转载本文请注明作者和出处
作者 ：JarvisChu
出处：http://blog.csdn.net/jarvischu

猜你喜欢

转载自blog.csdn.net/u011268787/article/details/78823739
今日推荐
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
周排行
NEFU 117 素数个数的位数
Closest Common Ancestors (Lca,tarjan)
ELK部署
【转载】Hive笔记整理（三）
SQL语句（一）基本表的定义
关于Java web开发中的MySQL的事务语句
MFC创建自定义窗体
如何用一句话激怒程序员？
《逆袭大学》文摘——9.4 基础和应用的平衡中找到大学的节奏
【spring源码分析】@Value注解原理
每日归档
更多
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022