【算法 | 实验6-1】n*n的网格,从左上角开始到右下角结束遍历所有的方块仅一次,总共有多少种不同的遍历路径

简介: 前言思路介绍中省略了关于如何进行回溯搜索的细节,而主要讨论回溯中所使用的剪枝策略。

前言

思路介绍中省略了关于如何进行回溯搜索的细节,而主要讨论回溯中所使用的剪枝策略。

68b9a51b1a7147b2bb726b29c3896b52.png

对于如图7×7的网格,从左上角开始到右下角结束遍历所有的方块仅一次,总共有多少种不同的遍历路径?

思路

基本思路:回溯法进行搜索。但纯暴力的搜索时间复杂度太大,需要加上剪枝的优化。

剪枝:可剪掉会导致不连通的走法,每走一步都判断是否联通。例如下图中的第五步,就将网格划分成了两片不连通的区域。

0e4c391edb354986af500be4502da8e1.png

判断联通性,思路1:

for 格子 in 所有网格
  if(以该格子作为起点进行搜索,能找到一条到达终点的路径)
    该格子与终点联通
if(所有格子都与终点联通)
  所有网格之间是联通的


即在一次是否联通的判断中,对应每个空的(没走过的)格子都进行一次回溯搜索。

到这里可能就会疑惑,剪枝的代价这么大,值得吗?答案是值得的,可以自己写有剪枝和纯暴力的程序对比一下。

看似一下只剪掉了一种情况,有时其实剪掉的相连的枝条是非常多的。

f079b2e2281540a0ae52c68017fccf11.png

剪枝效果:对题中 7 * 7 的网格,程序需要运行 2~3 分钟才能得到结果(毕竟搜索的基数还是太大了)。然而比纯暴力的情况好很多(纯暴力搜索我根本没看到结果)。

判断联通性,思路2:

前面的剪枝虽然有一些效果(至少可以看得见结果),然而每次剪枝代价还是偏大。每次判断联通,都对每个格子应用一次回溯搜索其实是不必要的。

那是一种比较静态的思路,你给我一张网格,告诉我哪些格子走过了(被覆盖),哪些格子没走过(空白),然后我告诉你它是不是联通。

另一种想法,就是考虑怎样走会导致不连通,因为状态从联通到不连通的转变只在某一步。

要把一块区域困死,走的路径就肯定会形成闭环,可以作以下断言:

if(我某一步后,前方是墙壁或走过的格子,且此时我两边都是没走过的格子)
  不连通
else
  联通

56e56f3bb93448ce9d51297b63ad0cf0.png

对剪枝进行优化后,仅需 2~3 秒即得到结果。

32fd1f0aaf404ddc97cbc29d17d1e4b9.png

实现(C++)

思路1

#include<iostream>
using namespace std;
const int Len =  7;//迷宫的边长 
//--------------------------------------------------
//复制一个二维数组,将在live()中被调用
void copy_mg(int source[][Len], int target[][Len]){
  for(int i = 0; i < Len; i++){
    for(int j = 0; j < Len; j++){
      target[i][j] = source[i][j];
    }
  }
} 
//--------------------------------------------------
//判断位置(y,x)是否仍与终点联通 
bool chance(int mg[][Len], int y, int x){
  //出来了吗?
  if(y == Len-1 && x == Len-1){
    return true;
  } 
  //1
  if(y < Len - 1) {
    mg[y][x] = '#';
    y++;
    if(mg[y][x] == 0){
      if(chance(mg, y, x)){
        return true;
      }
    }
    y--;
    mg[y][x] = 0;
  }
  //2
  if(y > 0) {
    mg[y][x] = '#';
    y--;
    if(mg[y][x] == 0){
      if(chance(mg, y, x)){
        return true;
      }
    }
    y++;
    mg[y][x] = 0;
  }
  //3
  if(x < Len - 1) {
    mg[y][x] = '#';
    x++;
    if(mg[y][x] == 0){
      if(chance(mg, y, x)){
        return true;
      }
    }
    x--;
    mg[y][x] = 0;
  }
  //4
  if(x > 0) {
    mg[y][x] = '#';
    x--;
    if(mg[y][x] == 0){
      if(chance(mg, y, x)){
        return true;
      }
    }
    x++;
    mg[y][x] = 0;
  }
  return false;
}
//--------------------------------------------------
//判断是否存在点被困死,未困死返回true 
bool live(int maze[][Len]){
  for(int i = 0; i < Len; i++){
    for(int j = 0; j < Len; j++){
      if(maze[i][j] > 0) continue;
      int mg[Len][Len] = {};
      copy_mg(maze, mg);
      bool t = chance(mg, i, j);
      if(! t){
        return false;
      }
    }
  }
  return true;
}
//--------------------------------------------------
//打印迷宫路径 
void printMaze(int maze[][Len]){
  for(int i = 0; i < Len; i++){
    for(int j = 0; j < Len; j++){
      printf("(%3d) ", maze[i][j]);
    }
    cout<<endl;
  }
  cout<<endl;
}
//--------------------------------------------------
//参数y为行标,x为列标 
void road(int maze[][Len], int y, int x, int & count, int num){
  num++;
  //不符合继续递归条件的情况:1、走到了墙上2、有点被困死再无法走到 
  if(maze[y][x] > 0 || live(maze) == 0){
    return;
  }
  //到达终点 
  if(x == Len-1 && y == Len-1){
    maze[y][x] = num;
    //判断是否走过了所有的点 
    if(maze[y][x] == Len * Len){
      count++;
      if(count % 10000 == 0) {
        cout<<"count: "<<count<<"  (y,x): "<<y<<" "<<x<<endl;
        printMaze(maze);
      }
    }
    maze[y][x] = 0;
    return;
  }
  //上 
  if(y - 1 >= 0){
    maze[y][x] = num;
    road(maze, y-1, x, count, num);
    maze[y][x] = 0;
  }
  //下
  if(y + 1 < Len){
    maze[y][x] = num;
    road(maze, y+1, x, count, num);
    maze[y][x] = 0;
  }
  //左
  if(x - 1 >= 0){
    maze[y][x] = num;
    road(maze, y, x-1, count, num);
    maze[y][x] = 0;
  }
  //右
  if(x + 1 < Len){
    maze[y][x] = num;
    road(maze, y, x+1, count, num);
    maze[y][x] = 0;
  }
}
//--------------------------------------------------
int main(){
  int maze[Len][Len] = {};
  int count = 0;//路径的数量 
  road(maze, 0, 0, count, 0);
  cout<<"result:"<<count<<endl;
  return 0;
}


思路2

//1.剪枝:不连通 
#include<iostream>
using namespace std;
const int Len =  7;//迷宫的边长 
//--------------------------------------------------
//判断走当前这一步是否会导致不连通
bool live(int maze[][Len], int y, int x){
  //上下堵,左右空 
  if((y+1 >= Len || maze[y+1][x] != 0) && (y-1 < 0 || maze[y-1][x] != 0)){
    if(x-1 >= 0 && maze[y][x-1] == 0 && x+1 < Len && maze[y][x+1] == 0){
      return false;
    }
  }
  //左右堵,上下空 
  else if((x+1 >= Len || maze[y][x+1] != 0) && (x-1 < 0 || maze[y][x-1] != 0)){
    if(y-1 >= 0 && maze[y-1][x] == 0 && y+1 < Len && maze[y+1][x] == 0){
      return false;
    }
  }
  return true;
} 
//--------------------------------------------------
//参数y为行标,x为列标 
void road(int maze[][Len], int y, int x, int & count, int num){
  //(y,x):当前坐标,count:路径总数,num:当前是第多少步 
  num++;
  //不符合继续递归条件的情况:1、走到了墙上2、有点被困死再无法走到 
  if(maze[y][x] > 0 || live(maze, y, x) == 0){
    return;
  }
  //到达终点 
  if(x == Len-1 && y == Len-1){
    maze[y][x] = num;
    //判断是否走过了所有的点 
    if(maze[y][x] == Len * Len){
      count++;
    }
    maze[y][x] = 0;
    return;
  }
  //上 
  if(y - 1 >= 0){
    maze[y][x] = num;
    road(maze, y-1, x, count, num);
    maze[y][x] = 0;
  }
  //下
  if(y + 1 < Len){
    maze[y][x] = num;
    road(maze, y+1, x, count, num);
    maze[y][x] = 0;
  }
  //左
  if(x - 1 >= 0){
    maze[y][x] = num;
    road(maze, y, x-1, count, num);
    maze[y][x] = 0;
  }
  //右
  if(x + 1 < Len){
    maze[y][x] = num;
    road(maze, y, x+1, count, num);
    maze[y][x] = 0;
  }
}
//--------------------------------------------------
int main(){
  int maze[Len][Len] = {};
  int count = 0;//路径的数量 
  road(maze, 0, 0, count, 0);
  cout<<"result:"<<count<<endl;
  return 0;
}


bug记录

在写live()函数时,我一开始的 if 语句如下。只有当前位置的上方或下方不是空格子,就判断为“碰到墙壁”。

//向上碰壁或向下碰壁
if(y+1 >= Len || maze[y+1][x] != 0 || y-1 < 0 || maze[y-1][x] != 0)

但后面发现,我给live()这个函数并没有传递“这一步是向哪个方向走达到的”这个方向信息,要判断碰壁应改为下面的代码(碰壁时,来的方向和走向的方向肯定都不是空格)。

if((y+1 >= Len || maze[y+1][x] != 0) && (y-1 < 0 || maze[y-1][x] != 0))

相关文章
|
2月前
|
算法 机器人 定位技术
【VRPTW】基于matlab秃鹰算法BES求解带时间窗的骑手外卖配送路径规划问题(目标函数:最优路径成本 含服务客户数量 服务时间 载量 路径长度)(Matlab代码实现)
【VRPTW】基于matlab秃鹰算法BES求解带时间窗的骑手外卖配送路径规划问题(目标函数:最优路径成本 含服务客户数量 服务时间 载量 路径长度)(Matlab代码实现)
|
16天前
|
机器学习/深度学习 传感器 算法
基于全局路径的无人地面车辆的横向避让路径规划研究[蚂蚁算法求解](Matlab代码实现)
基于全局路径的无人地面车辆的横向避让路径规划研究[蚂蚁算法求解](Matlab代码实现)
|
16天前
|
算法 数据挖掘 区块链
基于遗传算法的多式联运车辆路径网络优优化研究(Matlab代码实现)
基于遗传算法的多式联运车辆路径网络优优化研究(Matlab代码实现)
|
19天前
|
存储 算法 数据可视化
基于禁忌搜索算法的TSP问题最优路径搜索matlab仿真
本程序基于禁忌搜索算法解决旅行商问题(TSP),旨在寻找访问多个城市的最短路径。使用 MATLAB 2022A 编写,包含城市坐标生成、路径优化及结果可视化功能。通过禁忌列表、禁忌长度与藐视准则等机制,提升搜索效率与解的质量,适用于物流配送、路径规划等场景。
|
29天前
|
机器学习/深度学习 负载均衡 算法
【卡车和无人机协同配送路径优化】遗传算法求解利用一辆卡车和两架无人机配合,将小包裹递送给随机分布的客户,以使所有站点都由卡车或无人机递送一次后返回起始位置(中转站)研究(Matlab代码实现)
【卡车和无人机协同配送路径优化】遗传算法求解利用一辆卡车和两架无人机配合,将小包裹递送给随机分布的客户,以使所有站点都由卡车或无人机递送一次后返回起始位置(中转站)研究(Matlab代码实现)
|
25天前
|
机器学习/深度学习 传感器 算法
基于matlab瞬态三角哈里斯鹰算法TTHHO多无人机协同集群避障路径规划(目标函数:最低成本:路径、高度、威胁、转角)(Matlab代码实现)
基于matlab瞬态三角哈里斯鹰算法TTHHO多无人机协同集群避障路径规划(目标函数:最低成本:路径、高度、威胁、转角)(Matlab代码实现)
|
11天前
|
算法 数据可视化 异构计算
【车辆路径问题VRPTW】基于北极海鹦优化(APO)算法求解带时间窗的车辆路径问题VRPTW研究(Matlab代码实现)
【车辆路径问题VRPTW】基于北极海鹦优化(APO)算法求解带时间窗的车辆路径问题VRPTW研究(Matlab代码实现)
100 0
|
2月前
|
机器学习/深度学习 算法 数据挖掘
【配送路径规划】基于螳螂虾算法MShOA求解带时间窗的骑手外卖配送路径规划问题(目标函数:最优路径成本 含服务客户数量 服务时间 载量 路径长度)研究(Matlab代码实现)
【配送路径规划】基于螳螂虾算法MShOA求解带时间窗的骑手外卖配送路径规划问题(目标函数:最优路径成本 含服务客户数量 服务时间 载量 路径长度)研究(Matlab代码实现)
|
3月前
|
机器学习/深度学习 算法 Java
Java实现林火蔓延路径算法
记录正在进行的森林防火项目中林火蔓延功能,本篇文章可以较好的实现森林防火蔓延,但还存在很多不足,如:很多参数只能使用默认值,所以蔓延范围仅供参考。(如果底层设备获取的数据充足,那当我没说)。注:因林火蔓延涉及因素太多,如静可燃物载量、矿质阻尼系数等存在估值,所以得出的结果仅供参考。
55 4
|
4月前
|
数据采集 并行计算 算法
基于蚁群算法求解带时间窗的车辆路径问题
基于蚁群算法求解带时间窗的车辆路径问题
80 0

热门文章

最新文章