【基础算法】(08)五大常用算法之四:回溯法

【基础算法】(08)五大常用算法之四:回溯法

Auther: Thomas Shen
E-mail: Thomas.shen3904@qq.com
Date: 2017/10/24
All Copyrights reserved !

1. 简述:

本系列介绍了五大常用算法,其中本文是第四篇,介绍了 ‘回溯算法’ 的细节内容。

2. 算法原理:

回溯算法实际上一个类似枚举的搜索尝试过程,主要是在搜索尝试过程中寻找问题的解,当发现已不满足求解条件时,就“回溯”返回,尝试别的路径。

回溯法是一种选优搜索法,按选优条件向前搜索,以达到目标。但当探索到某一步时,发现原先选择并不优或达不到目标,就退回一步重新选择,这种走不通就退回再走的技术为回溯法,而满足回溯条件的某个状态的点称为“回溯点”。

许多复杂的,规模较大的问题都可以使用回溯法,有“通用解题方法”的美称。

2.1 基本思想:

在包含问题的所有解的解空间树中,按照深度优先搜索的策略,从根结点出发深度探索解空间树。当探索到某一结点时,要先判断该结点是否包含问题的解,如果包含,就从该结点出发继续探索下去,如果该结点不包含问题的解,则逐层向其祖先结点回溯。(其实回溯法就是对隐式图的深度优先搜索算法)。

若用回溯法求问题的所有解时,要回溯到根,且根结点的所有可行的子树都要已被搜索遍才结束。

而若使用回溯法求任一个解时,只要搜索到问题的一个解就可以结束。

2.2 算法步骤:
  1. 针对所给问题,确定问题的解空间;
  2. 首先应明确定义问题的解空间,问题的解空间应至少包含问题的一个(最优)解;
  3. 确定结点的扩展搜索规则;
  4. 以深度优先方式搜索解空间,并在搜索过程中用剪枝函数避免无效搜索。

3. 代码框架:

  1. 问题框架:

设问题的解是一个n维向量(a1,a2,………,an),约束条件是ai(i=1,2,3,…..,n)之间满足某种条件,记为f(ai)。

  1. 非递归回溯框架:
int a[n],i;
初始化数组a[];
i = 1;
while (i>0(有路可走) and (未达到目标))  // 还未回溯到头
{
    if(i > n) // 搜索到叶结点
    {   
        搜索到一个解,输出;
    }
    else // 处理第i个元素
    { 
        a[i]第一个可能的值;
        while(a[i]在不满足约束条件且在搜索空间内)
        {
            a[i]下一个可能的值;
        }
        if(a[i]在搜索空间内)
        {
            标识占用的资源;
            i = i+1; // 扩展下一个结点
        }
        else 
        {
            清理所占的状态空间; // 回溯
            i = i –1; 
        }
    }
}
  1. 递归的算法框架:

回溯法是对解空间的深度优先搜索,在一般情况下使用递归函数来实现回溯法比较简单。

在回溯法执行时,应当:保存当前步骤,如果是一个解就输出;维护状态,使搜索路径(含子路径)尽量不重复。必要时,应该对不可能为解的部分进行剪枝(pruning)。

bool finished = FALSE; /* 是否获得全部解? */
backtrack(int a[], int k, data input)
{
    int c[MAXCANDIDATES]; /*这次搜索的候选 */
    int ncandidates; /* 候选数目 */
    int i; /* counter */
    if (is_a_solution(a,k,input))
        process_solution(a,k,input);
    else {
        k = k+1;
        construct_candidates(a,k,input,c,&ncandidates);
        for (i=0; i<ncandidates; i++) {
            a[k] = c[i];
            make_move(a,k,input);
            backtrack(a,k,input);
            unmake_move(a,k,input);
            if (finished) 
                return; /* 如果符合终止条件就提前退出 */
        }
    }
}

对于其中的函数和变量,解释如下:
a[]表示当前获得的部分解;
k表示搜索深度;
input表示用于传递的更多的参数;
is_a_solution(a,k,input)判断当前的部分解向量a[1…k]是否是一个符合条件的解;
construct_candidates(a,k,input,c,ncandidates)根据目前状态,构造这一步可能的选择,存入c[]数组,其长度存入ncandidates;
process_solution(a,k,input)对于符合条件的解进行处理,通常是输出、计数等;
make_move(a,k,input)和unmake_move(a,k,input)前者将采取的选择更新到原始数据结构上,后者把这一行为撤销。

4. 应用案例:

  1. 0-1背包问题;
  2. 旅行售货员问题;
  3. 八皇后问题;
  4. 迷宫问题;
  5. 图的m着色问题。

1. 0-1背包问题:

问题:给定n种物品和一背包。物品i的重量是wi,其价值为pi,背包的容量为C。问应如何选择装入背包的物品,使得装入背包中物品的总价值最大?

分析:问题是n个物品中选择部分物品,可知,问题的解空间是子集树。比如物品数目n=3时,其解空间树如下图,边为1代表选择该物品,边为0代表不选择该物品。使用x[i]表示物品i是否放入背包,x[i]=0表示不放,x[i]=1表示放入。回溯搜索过程,如果来到了叶子节点,表示一条搜索路径结束,如果该路径上存在更优的解,则保存下来。如果不是叶子节点,是中点的节点(如B),就遍历其子节点(D和E),如果子节点满足剪枝条件,就继续回溯搜索子节点。

《【基础算法】(08)五大常用算法之四:回溯法》

#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 //放入背包 
            {   //约束条件:放的下 
                if((CurWeight+w[t])<=C)  
                {  
                    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;  
}  

2. 旅行售货员问题:
问题描述:
某售货员要到若干城市去推销商品,已知各城市之间的路程(或旅费)。他要选定一条从驻地出发,经过每个城市一次,最后回到驻地的路线,使总的路程(或总旅费)最小。
如下图:1,2,3,4 四个城市及其路线费用图,任意两个城市之间不一定都有路可达。
《【基础算法】(08)五大常用算法之四:回溯法》

回溯法:
http://blog.csdn.net/jarvischu/article/details/6058931

/********************************************************* *问 题:旅行售货员 *算 法:回溯法 *描 述:解空间为 排列树 *********************************************************/  
#include <stdio.h> 
#define N 4 //城市数目 
#define NO_PATH -1 //没有通路 
#define MAX_WEIGHT 4000 
int City_Graph[N+1][N+1];  //保存图信息 
int x[N+1];                //x[i]保存第i步遍历的城市 
int isIn[N+1];             //保存 城市i是否已经加入路径 
int bestw;                 //最优路径总权值 
int cw;                    //当前路径总权值 
int bestx[N+1];            //最优路径 
//----------------------------------------------------------------- 
void Travel_Backtrack(int t){        //递归法 
    int i,j;  
    if(t>N){                         //走完了,输出结果 
        for(i=1;i<=N;i++)            //输出当前的路径 
            printf("%d ",x[i]);  
        printf("/n");  
        if(cw < bestw){              //判断当前路径是否是更优解 
            for (i=1;i<=N;i++){  
                bestx[i] = x[i];  
            }  
            bestw = cw;  
        }  
        return;  
    }  
    else{  
        for(j=1;j<=N;j++){           //找到第t步能走的城市 
            if(City_Graph[x[t-1]][j] != NO_PATH && !isIn[j]){ //能到而且没有加入到路径中 
                isIn[j] = 1;  
                x[t] = j;  
                cw += City_Graph[x[t-1]][j];  
                Travel_Backtrack(t+1);  
                isIn[j] = 0;  
                x[t] = 0;  
                cw -= City_Graph[x[t-1]][j];  
            }  
        }  
    }  
}  
void main(){  
    int i;  
    City_Graph[1][1] = NO_PATH;  
    City_Graph[1][2] = 30;  
    City_Graph[1][3] = 6;  
    City_Graph[1][4] = 4;  

    City_Graph[2][1] = 30;  
    City_Graph[2][2] = NO_PATH;  
    City_Graph[2][3] = 5;  
    City_Graph[2][4] = 10;  
    City_Graph[3][1] = 6;  
    City_Graph[3][2] = 5;  
    City_Graph[3][3] = NO_PATH;  
    City_Graph[3][4] = 20;  

    City_Graph[4][1] = 4;  
    City_Graph[4][2] = 10;  
    City_Graph[4][3] = 20;  
    City_Graph[4][4] = NO_PATH;  
    //测试递归法 
    for (i=1;i<=N;i++){  
        x[i] = 0;               //表示第i步还没有解 
        bestx[i] = 0;           //还没有最优解 
        isIn[i] = 0;           //表示第i个城市还没有加入到路径中 
    }  

    x[1] = 1;                   //第一步 走城市1 
    isIn[1] = 1;                //第一个城市 加入路径 
    bestw = MAX_WEIGHT;  
    cw = 0;  
    Travel_Backtrack(2);        //从第二步开始选择城市 
    printf("最优值为%d/n",bestw);  
    printf("最优解为:/n");  
    for(i=1;i<=N;i++){  
        printf("%d ",bestx[i]);  
    }  
    printf("/n");  
}  

分支界限法:
http://blog.csdn.net/JarvisChu/article/details/5974895

3. 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,表示此位置可以摆放一个皇后。

《【基础算法】(08)五大常用算法之四:回溯法》

/************************************************************************ * 名 称: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)。这样代码会大大的简洁,因为节点的子节点数目会减少,判断冲突也更简单。

4. :

References. :

    原文作者:五大常用算法
    原文地址: https://blog.csdn.net/u011384489/article/details/78328915
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞