dfs bfs

dfs

运用递归和回溯的方式来找到起点到终点的最短路径，比如从起点出发，我们就有4个位置可以出发

我们先从右边向下一直递归搜索可以走的路，直到到达终点或者碰到不能走的时候，我们就把这个地点的标记去除然后再回到上一个点来进行下一个方向，这样子一直递归回溯，然后设置一个递归出口为到达终点就ok

#include 
int p, q,min=99999999;
int a[100][100];//地图2表示障碍物 1表示空地
int v[100][100];//0表示为访问，1表示访问
void dfs(int x,int y,int step)
{
	if (x == p && q == y)
	{
		if (step < min) min == step;
		return;
	}
	//向右
	if (a[x][y + 1] == 1 && v[x][y + 1] == 0)
	{
		v[x][y + 1] == 1;
		dfs(x, y + 1,step+1);
		v[x][y + 1] = 0;
	}
	//向下
	if (a[x+1][y] == 1 && v[x + 1][y] == 0)
	{
		v[x + 1][y] == 1;
		dfs(x+1, y, step + 1);
		v[x + 1][y]] = 0;
	}
	//向左
	if (a[x][y-1] == 1 && v[x][y - 1] == 0)
	{
		v[x][y - 1] == 1;
		dfs(x, y-1, step + 1);
		v[x][y - 1] = 0;
	}
	//向上
	if (a[x - 1][y] == 1 && v[x - 1][y] == 0)
	{
		v[x - 1][y] == 1;
		dfs(x -1, y, step + 1);
		v[x - 1][y] = 0;
	}
	return;
}
int dx[4] = { 0,1,0,-1 };
int dy[4] = { 1,0,-1,0 };
void dfspuls(int x, int y, int step)
{
	if (x == p && q == y)
	{
		if (step < min) min == step;
		return;
	}
	for (k = 0; k < 4; k++)
	{
		if (a[x + dx[k]][y + dy[k]] == 1 && v[x + dx[k]][y + dy[k]] == 0)
		{
			v[x + dx[k]][y + dy[k]] == 1;
			dfs(x + dx[k], y + dy[k], step + 1);
			v[x + dx[k]][y + dy[k]] == 0;
		}
	}
	return;
}
int main()
{
	int x, y;
	scanf("%d%d%d%d", x, y,p,q);
	for (int i = 1; i <= x; i++)
	{
		for (int j = 1; j <= y; j++)
		{
			scanf("%d", &a[i][j]);
		}
	}
	dfs(1, 1,0);
	printf("%d", min);
}

bfs

我们起点开始为0步数并把起点入队，然后再向4个方向走，每走一步加上1，并打上标记，然后我们再把这个起点上下左右四个方向都走一下并入队，和打上标记，然后再将队首出队，然后我们再走现在队首的元素，这样子一直循环下去，直到都被打上标记或者队内元素为0时退出循环，得到最短路径的步数

#include 
#include 
struct node
{
	int x, y, step;
};
queue r;
int map[100][100];
int v[100][100];
int dx[4] = { 0,1,0,-1 };
int dy[4] = { 1,0,-1,0 };
int main()
{
	int a, b;
	int starx, stary, n, m;
	scanf("%d%d", &a, &b);
	for (int i = 1; i <= a; i++)
	{
		for (int j = 1; j <= b; j++)
		{
			scanf("%d", &map[i][j]);
		}
	}
	scanf("%d%d%d%d", &starx, &stary, &n, &m);
	node star;
	star.x = starx;
	star.y = stary;
	star.step = 0;
	r.push(star);
	v[starx][stary] = 1;
	int flag = 0;
	while (!r.empty)
	{
		int x = r.front().x;
		int y = r.front().y;
		if (x == n && y == m)
		{
			flag = 1;
			printf("%d\n", r.front().step);
			break;
		}
		for (int k = 0; k < 4; k++)
		{
			int xx = x + dx[k], yy = y + dy[k];
			if (map[xx][yy] = 1 && v[xx][yy] = 0)
			{
				node teap;
				teap.x = xx;
				teap.y = yy;
				teap.step = r.front().step + 1;
				r.push(teap);
				v[xx][yy] = 1;
			}
		}
		r.pop();
	}
	if (flag == 0)
	{
		printf("没有可到达路径");
	}
}

这个是运用了c语言函数里面的queue，自己再手写队列的话太麻烦了，明天再把并查集和二叉树和二叉搜索树复习一下