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

相关文章
|
5天前
|
算法 Java 测试技术
算法分析(蛮力法与减治算法应用实验报告)
这篇文章是关于算法分析的实验报告,介绍了如何使用蛮力法解决背包问题,并通过伪代码和Java代码实现,同时分析了其时间效率;还介绍了基于减治法思想实现的二叉查找树的插入与查找,同样提供了伪代码、Java源代码实现和时间效率分析,最后展示了测试结果截图。
算法分析(蛮力法与减治算法应用实验报告)
|
5天前
|
机器学习/深度学习 算法 Java
算法设计(动态规划应用实验报告)实现基于贪婪技术思想的Prim算法、Dijkstra算法
这篇文章介绍了基于贪婪技术思想的Prim算法和Dijkstra算法,包括它们的伪代码描述、Java源代码实现、时间效率分析,并展示了算法的测试用例结果,使读者对贪婪技术及其应用有了更深入的理解。
算法设计(动态规划应用实验报告)实现基于贪婪技术思想的Prim算法、Dijkstra算法
|
5天前
|
算法 Java 测试技术
算法设计(动态规划实验报告) 基于动态规划的背包问题、Warshall算法和Floyd算法
这篇文章介绍了基于动态规划法的三种算法:解决背包问题的递归和自底向上实现、Warshall算法和Floyd算法,并提供了它们的伪代码、Java源代码实现以及时间效率分析。
算法设计(动态规划实验报告) 基于动态规划的背包问题、Warshall算法和Floyd算法
|
7天前
|
算法
基于多路径路由的全局感知网络流量分配优化算法matlab仿真
本文提出一种全局感知网络流量分配优化算法,针对现代网络中多路径路由的需求,旨在均衡分配流量、减轻拥塞并提升吞吐量。算法基于网络模型G(N, M),包含N节点与M连接,并考虑K种不同优先级的流量。通过迭代调整每种流量在各路径上的分配比例,依据带宽利用率um=Σ(xm,k * dk) / cm来优化网络性能,确保高优先级流量的有效传输同时最大化利用网络资源。算法设定收敛条件以避免陷入局部最优解。
|
5天前
|
算法 搜索推荐
算法设计 (分治法应用实验报告)基于分治法的合并排序、快速排序、最近对问题
这篇文章是关于分治法应用的实验报告,详细介绍了如何利用分治法实现合并排序和快速排序算法,并探讨了使用分治法解决二维平面上的最近对问题的方法,包括伪代码、源代码实现及时间效率分析,并附有运行结果和小结。
|
11天前
|
存储 算法 Java
LeetCode经典算法题:二叉树遍历(递归遍历+迭代遍历+层序遍历)以及线索二叉树java详解
LeetCode经典算法题:二叉树遍历(递归遍历+迭代遍历+层序遍历)以及线索二叉树java详解
29 0
|
1月前
|
存储 算法 Python
“解锁Python高级数据结构新姿势:图的表示与遍历,让你的算法思维跃升新高度
【7月更文挑战第13天】Python中的图数据结构用于表示复杂关系,通过节点和边连接。常见的表示方法是邻接矩阵(适合稠密图)和邻接表(适合稀疏图)。图遍历包括DFS(深度优先搜索)和BFS(广度优先搜索):DFS深入探索分支,BFS逐层访问邻居。掌握这些技巧对优化算法和解决实际问题至关重要。**
21 1
|
1月前
|
机器学习/深度学习 数据采集 算法
Python实现GBDT(梯度提升树)分类模型(GradientBoostingClassifier算法)并应用网格搜索算法寻找最优参数项目实战
Python实现GBDT(梯度提升树)分类模型(GradientBoostingClassifier算法)并应用网格搜索算法寻找最优参数项目实战
|
1月前
|
机器学习/深度学习 人工智能 分布式计算
算法金 | 最难的来了:超参数网格搜索、贝叶斯优化、遗传算法、模型特异化、Hyperopt、Optuna、多目标优化、异步并行优化
机器学习中的超参数调优是提升模型性能的关键步骤,包括网格搜索、随机搜索、贝叶斯优化和遗传算法等方法。网格搜索通过穷举所有可能的超参数组合找到最优,但计算成本高;随机搜索则在预设范围内随机采样,降低计算成本;贝叶斯优化使用代理模型智能选择超参数,效率高且适应性强;遗传算法模拟生物进化,全局搜索能力强。此外,还有多目标优化、异步并行优化等高级技术,以及Hyperopt、Optuna等优化库来提升调优效率。实践中,应结合模型类型、数据规模和计算资源选择合适的调优策略。
67 0
算法金 | 最难的来了:超参数网格搜索、贝叶斯优化、遗传算法、模型特异化、Hyperopt、Optuna、多目标优化、异步并行优化
|
1月前
|
算法 JavaScript
JS 【详解】树的遍历(含深度优先遍历和广度优先遍历的算法实现)
JS 【详解】树的遍历(含深度优先遍历和广度优先遍历的算法实现)
26 0
JS 【详解】树的遍历(含深度优先遍历和广度优先遍历的算法实现)

热门文章

最新文章