【算法 | 实验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))

相关文章
|
1月前
|
算法
分享一些提高二叉树遍历算法效率的代码示例
这只是简单的示例代码,实际应用中可能还需要根据具体需求进行更多的优化和处理。你可以根据自己的需求对代码进行修改和扩展。
|
1月前
|
存储 缓存 算法
如何提高二叉树遍历算法的效率?
选择合适的遍历算法,如按层次遍历树时使用广度优先搜索(BFS),中序遍历二叉搜索树以获得有序序列。优化数据结构,如使用线索二叉树减少空指针判断,自定义节点类增加辅助信息。利用递归与非递归的特点,避免栈溢出问题。多线程并行遍历提高速度,注意线程安全。缓存中间结果,避免重复计算。预先计算并存储信息,提高遍历效率。综合运用这些方法,提高二叉树遍历算法的效率。
58 5
|
1月前
|
算法
树的遍历算法有哪些?
不同的遍历算法适用于不同的应用场景。深度优先搜索常用于搜索、路径查找等问题;广度优先搜索则在图的最短路径、层次相关的问题中较为常用;而二叉搜索树的遍历在数据排序、查找等方面有重要应用。
36 2
|
1月前
|
机器学习/深度学习 JSON 算法
二叉树遍历算法的应用场景有哪些?
【10月更文挑战第29天】二叉树遍历算法作为一种基础而重要的算法,在许多领域都有着不可或缺的应用,它为解决各种复杂的问题提供了有效的手段和思路。随着计算机科学的不断发展,二叉树遍历算法也在不断地被优化和扩展,以适应新的应用场景和需求。
40 0
|
2月前
|
数据采集 监控 安全
厂区地图导航制作:GIS技术与路径导航算法融合
在智能化、数字化时代,GIS技术为厂区的运营管理带来了革命性变化。本文探讨了如何利用GIS技术,通过数据采集、地图绘制、路径规划、位置定位和信息查询等功能,打造高效、精准的智能厂区地图导航系统,提升企业的竞争力和管理水平。
78 0
厂区地图导航制作:GIS技术与路径导航算法融合
|
2月前
|
算法 搜索推荐 Java
java 后端 使用 Graphics2D 制作海报,画echarts图,带工具类,各种细节:如头像切割成圆形,文字换行算法(完美实验success),解决画上文字、图片后不清晰问题
这篇文章介绍了如何使用Java后端技术,结合Graphics2D和Echarts等工具,生成包含个性化信息和图表的海报,并提供了详细的代码实现和GitHub项目链接。
147 0
java 后端 使用 Graphics2D 制作海报,画echarts图,带工具类,各种细节:如头像切割成圆形,文字换行算法(完美实验success),解决画上文字、图片后不清晰问题
|
2月前
|
存储 算法
数据结构与算法学习十六:树的知识、二叉树、二叉树的遍历(前序、中序、后序、层次)、二叉树的查找(前序、中序、后序、层次)、二叉树的删除
这篇文章主要介绍了树和二叉树的基础知识,包括树的存储方式、二叉树的定义、遍历方法(前序、中序、后序、层次遍历),以及二叉树的查找和删除操作。
31 0
|
2月前
|
算法
计科一二班算法数据结构实验9答案
计科一二班算法数据结构实验9答案
18 0
|
4月前
|
算法 Java 测试技术
算法分析(蛮力法与减治算法应用实验报告)
这篇文章是关于算法分析的实验报告,介绍了如何使用蛮力法解决背包问题,并通过伪代码和Java代码实现,同时分析了其时间效率;还介绍了基于减治法思想实现的二叉查找树的插入与查找,同样提供了伪代码、Java源代码实现和时间效率分析,最后展示了测试结果截图。
算法分析(蛮力法与减治算法应用实验报告)
|
4月前
|
机器学习/深度学习 算法 Java
算法设计(动态规划应用实验报告)实现基于贪婪技术思想的Prim算法、Dijkstra算法
这篇文章介绍了基于贪婪技术思想的Prim算法和Dijkstra算法,包括它们的伪代码描述、Java源代码实现、时间效率分析,并展示了算法的测试用例结果,使读者对贪婪技术及其应用有了更深入的理解。
算法设计(动态规划应用实验报告)实现基于贪婪技术思想的Prim算法、Dijkstra算法
下一篇
DataWorks