dfs 迷宫图

6 篇文章 0 订阅
4 篇文章 0 订阅
//find.cpp

#include "pch.h"
#include<STDIO.H>
int kk = 13;                  //假设的最大步数
int KK[12] = { 0 };             //记录短路程轨迹
int SUM = 0;                  //每种算法步数
int hh[26] = { 0 };             //每种算法轨迹
int pp[13];


void copy(int(*a)[13], int(*b)[13])                                //复制函数
{
	int x, y;
	for (x = 0; x < 13; x++)
		for (y = 0; y < 13; y++)
			a[x][y] = b[x][y];
}


int find(int a, int b, int(*p)[13],int sum)      //a-开始点,b-目标点
{
	/*if(a>11||b>11)
		return;*/
	if (sum > kk)                                //步数过多返回
		return 0;
	static int found = 0;
	int i = 1;
	int flag = 0;
	for (; i < 12; i++)                                  //找和a连通的点
	{
		if (p[a][i] == 1 && p[i][i] == 0 && a != i)          //查找一个符合的点
		{
			flag = 1;
		}
		if (0 == flag)                                //查找失败返回
			continue;
		//while (flag)                           //查找成功时进行操作
		{
			//printf("sum=%d\n", p[a][i]);
			int temp[13][13] = { 0 };
			copy(temp, p);
			temp[a][i] = temp[i][a] = 2;
			temp[a][a] = 1;
			sum++;
			//printf("%d\n", a);
			if (i == b)                          //找到为目标点
			{
				found++;                               //标记,非零即有结果
				//printf("sum=%d\n", sum);
				if (sum < kk)
				{
					//  change(KK,hh);
					kk = sum;
				}
				if (kk == 5)
					int bf = 0;
				return 1;
			}
			int flag1=find(i, b, temp,sum);                   //递归到下一层,并且记录该路径是否有效
			temp[a][i] = temp[i][a] = 1;                      //改回原值,为查找另外一个路径做准备
			temp[a][a] = 0;
			sum--;
			flag = 0;
			
		}
	}
	if (found)                                               //若找到,返回值为1
		return 1;
	else
		return 0;
}



//mian.cpp
// 迷宫图.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include "pch.h"
#include<stdio.h>

extern int SUM;
extern int kk;           
int find(int, int, int(*p)[13],int);


int main()
{
	int a[13][13] = { 0 };        
	a[1][2] = a[2][1] = a[1][5] = a[5][1] = a[1][4] = a[4][1] = a[2][5] = a[5][2] = a[2][3] = a[3][2] = 1;
	a[3][5] = a[5][3] = a[3][6] = a[6][3] = 1;
	a[9][4] = a[4][9]/* = a[4][5] = a[5][4] = a[4][8] = a[8][4] = a[4][7] = a[7][4]*/ = 1;
	a[5][8] = a[8][5] = 1;
	a[6][8] = a[8][6] = a[6][11] = a[11][6] = 1;
	a[7][8] = a[8][7] = a[8][11] = a[11][8] = a[11][10] = a[10][11] = a[7][10] = a[10][7] = 1;      //手动输入,比较傻雕
/*	if (find(5, 10, a, 0))
		printf("Bingo\n");
	else
		printf("Error\n");
	printf("Result:\n%d\n", kk);*/
	if (find(10, 4, a, 0))
		printf("Bingo\n");
	else
		printf("Error\n");
	printf("Result:\n%d\n", kk);
	if (find(1,10, a, 0))
		printf("Bingo\n");
	else
		printf("Error\n");
	printf("Result:\n%d\n", kk);
	return 0;
}


相对于上次的周游问题,对于递归回溯的算法有了多一点的理解
最大的不足:
变量设置太多,内存消耗大

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
深度优先搜索(DFS)是一种常用的遍历算法,可以用来解决迷宫问题。下面是一种基于DFS的求解迷宫所有路径的算法: 1. 定义一个二维数组maze表示迷宫,其中0表示可走的路,1表示墙,2表示已经走过的路。 2. 定义一个栈stack,用来存储走过的路径。 3. 定义一个列表paths,用来存储所有走过的路径。 4. 定义一个函数dfs(x, y)表示从坐标为(x, y)的位置开始走迷宫。 5. 在函数dfs(x, y)中,如果当前位置为终点,则将stack中的路径添加到paths中,并返回。 6. 如果当前位置不是终点,则将当前位置标记为已经走过,然后按照上、右、下、左的顺序依次尝试往下一个位置走。 7. 如果下一个位置是可走的路,则将其入栈,并递归调用dfs函数继续走迷宫。 8. 如果下一个位置已经走过或者是墙,则不再尝试走这个方向。 9. 最后,将当前位置标记为未走过,将stack中的最后一个位置弹出,表示回溯到上一步。 下面是Python代码实现: ```python maze = [ [0, 1, 0, 0], [0, 0, 0, 1], [1, 0, 1, 0], [0, 0, 0, 0] ] stack = [(0, 0)] paths = [] def dfs(x, y): if x == len(maze) - 1 and y == len(maze[0]) - 1: paths.append(list(stack)) return maze[x][y] = 2 for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]: nx, ny = x + dx, y + dy if 0 <= nx < len(maze) and 0 <= ny < len(maze[0]) and maze[nx][ny] == 0: stack.append((nx, ny)) dfs(nx, ny) stack.pop() maze[x][y] = 0 dfs(0, 0) for path in paths: print(path) ``` 以上代码输出所有从起点到终点的路径。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值