图-DFS-BFS-迷宫类问题

DFS-栈

#include<iostream>
using namespace std;
#include<stack>
int matrix[7][7] = {
		   //A,B,C,D,E,F,G
	/*A*/	{0,0,1,1,0,1,0},
	/*B*/	{0,0,1,0,0,0,0},
	/*C*/	{1,1,0,1,0,0,0},
	/*D*/	{1,0,1,0,0,0,0},
	/*E*/	{0,0,0,0,0,0,1},
	/*F*/	{1,0,0,0,0,0,1},
	/*G*/	{0,0,0,0,1,1,0}
};
bool vis[7];//标记数组
//深度优先搜索
void dfs() {
	stack<int> s;
	//从A开始搜索
	s.push(0);
	vis[0] = 1;
	while (!s.empty()) {
		int tmp = s.top();
		s.pop();
		cout << char(tmp + 'A');//转为ascii码
		for (int i = 0; i < 7; i++) {
			if (matrix[tmp][i] != 0 && !vis[i]) {
				s.push(i);
				vis[i] = 1;
			}
		}
	}
}


int main() {
	dfs();
}

DFS-递归

#include<iostream>
using namespace std;
int matrix[7][7] = {
		   //A,B,C,D,E,F,G
	/*A*/	{0,0,1,1,0,1,0},
	/*B*/	{0,0,1,0,0,0,0},
	/*C*/	{1,1,0,1,0,0,0},
	/*D*/	{1,0,1,0,0,0,0},
	/*E*/	{0,0,0,0,0,0,1},
	/*F*/	{1,0,0,0,0,0,1},
	/*G*/	{0,0,0,0,1,1,0}
};
bool vis[7];
int maxx = 0;
//dfs()里面的index叫作参数，dep叫阶段，也就是到了递归的第几层
void dfs(int index, int dep) {
	maxx = max(maxx, dep);
	vis[index] = 1;
	cout << char(index + 'A');
	for (int i = 0; i < 7; i++) {
		if (matrix[index][i] == 1 && !vis[i]) {
			dfs(i, dep+1);//不能用dep++，需要保证A始终在第一层，也就是A对应的dep为1
		}
	}
}


int main() {
	dfs(0,1);
	cout << "最长搜索深度为：" << maxx;
	return 0;
}

BFS

#include<iostream>
using namespace std;
#include<queue>
int matrix[7][7] = {
	//A,B,C,D,E,F,G
	/*A*/	{0,0,1,1,0,1,0},
	/*B*/	{0,0,1,0,0,0,0},
	/*C*/	{1,1,0,1,0,0,0},
	/*D*/	{1,0,1,0,0,0,0},
	/*E*/	{0,0,0,0,0,0,1},
	/*F*/	{1,0,0,0,0,0,1},
	/*G*/	{0,0,0,0,1,1,0}
};


bool vis[7];
int maxdep = 0;
void bfs() {
	queue<int> q;
	q.push(0);
	vis[0] = 1;//入队就置1
	int last = 0, nlast = 0;
	while (!q.empty()) {
		int tmp = q.front();
		q.pop();
		cout << char(tmp + 'A') << " ";
		for (int i = 0; i < 7; i++) {
			if (matrix[tmp][i] == 1 && !vis[i]) {
				q.push(i);
				vis[i] = 1;//每次进队列，在这里就要置1
				nlast = i;
			}
		}
		if (tmp == last) {
			cout << endl;//换行
			last = nlast;
			maxdep++;
		}
	}
}

// 这里是用一个结构体，不用树里的last和nlast了
//struct node {
//	int index;
//	int dep;
//	node(int id, int d) {//用了一个有参构造
//		index = id;
//		dep = d;
//	}
//};
//bool vis[7];
//int maxdep = 0;
//void bfs() {
//	queue<node> q;
//	q.push(node(0,1));//有参构造
//	//q.push(node{ 0,1 });//列表初始化
//	vis[0] = 1;//入队就置1
//
//	while (!q.empty()) {
//		node tmp = q.front();
//		q.pop();
//		maxdep = max(maxdep, tmp.dep);
//		cout << char(tmp.index + 'A') << " ";
//		for (int i = 0; i < 7; i++) {
//			if (matrix[tmp.index][i] == 1 && !vis[i]) {
//				q.push(node{i,tmp.dep+1});
//				vis[i] = 1;//每次进队列，在这里就要置1
//			}
//		}
//	}
//}


int main() {
	bfs();
	cout << "最大搜索层数为：" << maxdep;
	return 0;
}

迷宫问题

#include<iostream>
using namespace std;
/*   
S**.
....
***F
S:起点 F：终点 *：墙壁 
*/

char maze[101][101];//迷宫数组
bool vis[101][101];//标记数组
int n, m;//n行m列
int sx, sy,/*起点坐标*/ fx, fy;/*终点坐标*/
bool flag = false;//是否走到F的标志
//方向数组	 右左下上
int dx[] = { 0,0,1,-1 };
int dy[] = { 1,-1,0,0 };
//x,y是状态
//深搜：1、先进后出 2、标记 3、邻接点（方向数组），也就是和图中类似，遍历邻接点
void dfs(int x, int y) {
	//如果搜索到的某个状态恰好是终点
	if (x == fx && y == fy) {
		flag = true;
		return;
	}
	//遍历方向数组，也就是四个可以走的方向
	for (int i = 0; i < 4; i++) {
		int bx = x + dx[i], by = y + dy[i];
		//如果越界，无需搜索，重新生成新的位置
		if (bx < 0 || bx >= n || by < 0 || by >= m) continue;
		//如果生成的新位置是墙壁，无需搜索，重新生成新的位置
		if (maze[bx][by] == '*') continue;
		//如果生成的新位置走过了（被标记），无需重复搜索，重新生成新的位置
		if (vis[bx][by]) continue;
		vis[bx][by] = 1;
		dfs(bx, by);
	}
}
int main() {
	cin >> n >> m;
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < m; j++) {
			cin >> maze[i][j];
			if (maze[i][j] == 'S') {
				sx = i;
				sy = j;//记录起点位置
			}
			if (maze[i][j] == 'F') {
				fx = i;
				fy = j;//记录终点位置
			}
		}
	}
	vis[sx][sy] = 1;//标记起点
	dfs(sx, sy);//初始状态
	cout << (flag ? "YES\n" : "NO\n");
	return 0;
}