图的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 = 1;
//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();
//		if (tmp.dep - maxdep == 1) cout << endl;//换行
//		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;
}

迷宫问题-DFS

#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 max_dep = 0;
//方向数组	 右左下上
int dx[] = { 0,0,1,-1 };
int dy[] = { 1,-1,0,0 };
//x,y是状态
//深搜：1、先进后出 2、标记 3、邻接点（方向数组），也就是和图中类似，遍历邻接点
void dfs(int x, int y, int dep) {
	//如果搜索到的某个状态恰好是终点
	if (x == fx && y == fy) {
		flag = true;
		max_dep = max(max_dep, dep);
		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, dep+1);
	}
}
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, 0);//初始状态
	cout << (flag ? "YES\n" : "NO\n");
	cout << "搜索深度为：" << max_dep;
	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 = 1;
//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();
//		if (tmp.dep - maxdep == 1) cout << endl;//换行
//		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;
#define INF 0x3f3f3f3f
#define row 7
#define col 7
int matrix[row][col]{
		//A   B   C   D  E	F	G
/*A*/	{INF,12,INF,INF,INF,16,14},
/*B*/	{12,INF,10,INF,INF,7,INF},
/*C*/	{INF,10,INF,3,6,5,INF},
/*D*/	{INF,INF,3,INF,4,INF,INF},
/*E*/	{INF,INF,5,4,INF,2,8},
/*F*/	{16,7,6,INF,2,INF,9},
/*G*/	{14,INF,INF,INF,8,9,INF}
};

int vis[7], s[7], u[7], nextnode[7];

void Dijkstra(int index) {
	vis[index] = 1;
	for (int i = 0; i < 7; i++) {//先得到U集合，也就是未计算出最短路径的定点的集合
		u[i] = matrix[index][i];//index到各点的距离
	}
	int min_cur = index;//记录哪个点到index的距离最小
	int count = 6;
	while (count--) {
		int minx = INF;
		for (int i = 0; i < 7; i++) {
			if (!vis[i] && u[i] < minx) {//找到最小的距离，更新S集合
				minx = u[i];
				min_cur = i;
			}
		}
		vis[min_cur] = 1;//标记，说明已经进了S集合
		s[min_cur] = minx;
		//由刚才计算出的最短路径的点，计算其它点通过该点的到index的距离，是否比原来的要更小
		for (int i = 0; i < 7; i++) {
			int tmp = matrix[i][min_cur] == INF ? INF : minx + matrix[i][min_cur];
			if (!vis[i] && tmp < u[i]) {
				u[i] = tmp;//更小的话，则更新U集合
				nextnode[i] = min_cur;
			}
		}
	}
}
int main() {
	for (int i = 0; i < 7; i++) {
		nextnode[i] = -1;
	}
	Dijkstra('D' - 'A');//求D点到各点的最短距离
	for (int i = 0; i < 7; i++) {
		cout << "D到" << char(i + 'A') << "的最短距离为：" << s[i] << endl;
	}
	int index = 0;
	while (index != -1) {
		cout << char(index + 'A');
		index = nextnode[index];
	}
	cout << "D";
	return 0;
}

搜索与回溯模板

#include<iostream>
using namespace std;
string s;
bool vis[7];//标记数组，看是否已经搜索过
char ans[7];
//搜索与回溯模板题-全排列
void dfs(int dep) {//dep这个参数大部分情况都用得到，写dfs的时候直接加上
	//6.终止条件+数据处理
	if (dep == s.size() + 1) {
		//搜索打印原则：搜多少，打印多少
		for (int i = 1; i < dep; i++) {
			//打印优化：优先使用C语言的输出
			printf("%c", ans[i]);
		}
		printf("\n");
		return;
	}
	//1.枚举方案数
	for (int i = 0; i < s.size(); i++) {
		//2.标记，防止重复搜索
		if (!vis[i]) {
			vis[i] = 1;//标记
			//3.搜索当前层
			ans[dep] = s[i];
			//4.进入到下一层去搜索
			dfs(dep + 1);
			//5.回溯-还原相关状态
			vis[i] = 0;
		}
	}
}

int main() {
	cin >> s;
	dfs(1);
	return 0;
}