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

2024-06-06 17:58
文章标签 算法 08 之四 回溯 五大 常用 基础

本文主要是介绍【基础算法】(08)五大常用算法之四：回溯法，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

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

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

      • 基础算法08五大常用算法之四回溯法
        • 简述
        • 算法原理
          • 1 基本思想
          • 2 算法步骤
        • 代码框架
        • 应用案例
        • References

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），如果子节点满足剪枝条件，就继续回溯搜索子节点。

这里写图片描述

#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 四个城市及其路线费用图，任意两个城市之间不一定都有路可达。
这里写图片描述

回溯法：
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，表示此位置可以摆放一个皇后。

这里写图片描述

/************************************************************************  * 名  称：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. ：
  • [ 1 ]. Coursera | Java程序设计 | PKU
  • [ 2 ]. http://blog.csdn.net/yake827/article/details/52119469
  • [ 3 ]. http://www.cnblogs.com/wuyuegb2312/p/3273337.html
  • [ 4 ]. http://blog.csdn.net/jarvischu/article/details/16067319
  • [ 5 ]. http://blog.csdn.net/jarvischu/article/details/6058931
  • [ 6 ].

这篇关于【基础算法】(08)五大常用算法之四：回溯法的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1036827。

相关文章

RedHat运维-Linux文本操作基础-AWK进阶

RedHat运维-Linux文本操作基础-AWK进阶

你不用整理，跟着敲一遍，有个印象，然后把它保存到本地，以后要用再去看，如果有了新东西，你自个再添加。这是我参考牛客上的shell编程专项题，只不过换成了问答的方式而已。不用背，就算是我自己亲自敲，我现在好多也记不住。 1. 输出nowcoder.txt文件第5行的内容 2. 输出nowcoder.txt文件第6行的内容 3. 输出nowcoder.txt文件第7行的内容 4. 输出nowcode
阅读更多...
Vim使用基础篇

Vim使用基础篇

本文内容大部分来自 vimtutor，自带的教程的总结。在终端输入vimtutor 即可进入教程。 先总结一下，然后再分别介绍正常模式，插入模式，和可视模式三种模式下的命令。 目录 看完以后的汇总 1.正常模式（Normal模式） 1.移动光标 2.删除 3.【:】输入符 4.撤销 5.替换 6.重复命令【. ; ,】 7.复制粘贴 8.缩进 2.插入模式 INSERT
阅读更多...
零基础STM32单片机编程入门(一)初识STM32单片机

零基础STM32单片机编程入门(一)初识STM32单片机

文章目录 一.概要二.单片机型号命名规则三.STM32F103系统架构四.STM32F103C8T6单片机启动流程五.STM32F103C8T6单片机主要外设资源六.编程过程中芯片数据手册的作用1.单片机外设资源情况2.STM32单片机内部框图3.STM32单片机管脚图4.STM32单片机每个管脚可配功能5.单片机功耗数据6.FALSH编程时间，擦写次数7.I/O高低电平电压表格8.外设接口
阅读更多...
ps基础入门

ps基础入门

1.基础      1.1新建文件      1.2创建指定形状      1.4移动工具          1.41移动画布中的任意元素          1.42移动画布          1.43修改画布大小          1.44修改图像大小      1.5框选工具      1.6矩形工具      1.7图层          1.71图层颜色修改          1
阅读更多...
React+TS前台项目实战（十七）-- 全局常用组件Dropdown封装

React+TS前台项目实战（十七）-- 全局常用组件Dropdown封装

文章目录 前言Dropdown组件1. 功能分析2. 代码+详细注释3. 使用方式4. 效果展示 总结 前言 今天这篇主要讲全局Dropdown组件封装，可根据UI设计师要求自定义修改。 Dropdown组件 1. 功能分析 （1）通过position属性,可以控制下拉选项的位置 （2）通过传入width属性, 可以自定义下拉选项的宽度 （3）通过传入classN
阅读更多...
代码随想录算法训练营：12/60

代码随想录算法训练营：12/60

非科班学习算法day12 | LeetCode150:逆波兰表达式 ，Leetcode239: 滑动窗口最大值  目录 介绍 一、基础概念补充： 1.c++字符串转为数字 1. std::stoi, std::stol, std::stoll, std::stoul, std::stoull（最常用） 2. std::stringstream 3. std::atoi, std
阅读更多...
人工智能机器学习算法总结神经网络算法(前向及反向传播)

人工智能机器学习算法总结神经网络算法(前向及反向传播)

1.定义，意义和优缺点 定义: 神经网络算法是一种模仿人类大脑神经元之间连接方式的机器学习算法。通过多层神经元的组合和激活函数的非线性转换，神经网络能够学习数据的特征和模式，实现对复杂数据的建模和预测。(我们可以借助人类的神经元模型来更好的帮助我们理解该算法的本质，不过这里需要说明的是，虽然名字是神经网络，并且结构等等也是借鉴了神经网络，但其原型以及算法本质上还和生物层面的神经网络运行原理存在
阅读更多...
[FPGA][基础模块]跨时钟域传播脉冲信号

[FPGA][基础模块]跨时钟域传播脉冲信号

clk_a 周期为10ns clk_b 周期为34ns 代码: module pulse(input clk_a,input clk_b,input signal_a,output reg signal_b);reg [4:0] signal_a_widen_maker = 0;reg signal_a_widen;always @(posedge clk_a)if(signal_a)
阅读更多...
00 - React 基础

00 - React 基础

1. React 基础 安装react指令 可参考： 官网官网使用教程 如： npx create-react-app 项目名如：npx create-react-app react-redux-pro JSX JSX 是一种 JavaScript 的语法扩展，类似于 XML 或 HTML，允许我们在 JavaScript 代码中编写 HTML。 const element =
阅读更多...
大林 PID 算法

大林 PID 算法

Dahlin PID算法是一种用于控制和调节系统的比例积分延迟算法。以下是一个简单的C语言实现示例： #include <stdio.h>// DALIN PID 结构体定义typedef struct {float SetPoint; // 设定点float Proportion; // 比例float Integral; // 积分float Derivative; // 微分flo
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2