每日算法：图的遍历+反向建边

题目来源：洛谷P3916

日期：2023.10.11

第3天

题目：

第一遍，正常建边 ，采用bfs()80分，两个测试点TLE，采用dfs()90分，一个测试点TLE；代码如下：

/*
	没有边的顶点，能到达的最大顶点编号就是它自己； 
*/

#include <iostream>
#include <cstdio>
#include <vector>
#include <cstring>
#include <queue>
using namespace std;
const int N = 100010;
bool inq[N] = {0};

int n, m;

vector<int> Adj[N];

int DFS(int u) {
	int numMax = u;
	inq[u] = 1;
	
	//遍历这个顶点可以到达的所有顶点
	for(int i = 0; i < Adj[u].size(); i++) {
		if(inq[Adj[u][i]] == 0) {
			numMax = max(numMax, DFS(Adj[u][i]));
		}
	} 
	return numMax;
}

int BFS(int u) {
	int numMax = u;
	
	queue<int> q;
	q.push(u);
	inq[u] = 1;
	
	while(!q.empty()) {
		int head = q.front();
		q.pop();
		
		for(int i = 0; i < Adj[head].size(); i++) {
			if(inq[Adj[head][i]] == 0) {
				q.push(Adj[head][i]);
				inq[Adj[head][i]] = 1;
				numMax = max(numMax, Adj[head][i]);
			}
		}
	}
	return numMax;
}

int main(void) {
	scanf("%d%d", &n, &m);
	for(int i = 0; i < m; i++) {
		int id1, id2;
		scanf("%d%d", &id1, &id2);
		Adj[id1].push_back(id2);
	}
	
	for(int i = 1; i <= n; i++) {
		memset(inq, 0, sizeof(inq));
//		int numMax = DFS(i);
		int numMax = BFS(i);
		printf("%d ", numMax);
	}
	
	return 0;
}

 看过题解之后，反向建边。

/*
	题目给的是，a到b的边，我们建边是b到a，代表b能到的顶点；
	求每个点能到达的编号最大的顶点，我们记录每个点能被达到的点的编号。
	邻接表Adj[i]存储的不再是顶点i能到达的点，而是能到达顶点i的点；
	于是，从Adj[n]遍历到Adj[1]，Adj[N]里存的点，能到达的最大顶点就是N；
	换句话说，从顶点N出发能访问到的点，答案就是N；
	反向建边，每个点只会被访问一次；复杂度为O(N) 
	 
	保证每个顶点只被访问一次，因为之后如果再访问到这个结点那么答案肯定没当前大了 
	
	
*/

#include <iostream>
#include <cstdio>
#include <vector>
#include <cstring>
#include <queue>
using namespace std;
const int N = 100010;
bool inq[N] = {0};
int ans[N] = {0};
int n, m;

vector<int> Adj[N];

//需要一个参数，这个参数应该是每一层的DFS()都一样，作为这些点的答案 
void DFS(int u, int maxNum) {
	
	if(inq[u] == 1) return ;
	ans[u] = maxNum;
	inq[u] = 1;
	
	for(int i = 0; i < Adj[u].size(); i++) {
		if(inq[Adj[u][i]] == 0) {
			ans[Adj[u][i]] = maxNum;
			DFS(Adj[u][i], maxNum);
		}
	}
}

void BFS(int u, int maxNum) {
	//如果这个点被遍历过了，就不用再遍历了； 
	if(inq[u] == 1) return ;
	
	queue<int> q;
	q.push(u);
	inq[u] = 1;
	ans[u] = maxNum;
	
	while(!q.empty()) {
		int head = q.front();
		q.pop();
		
		for(int i = 0; i < Adj[head].size(); i++) {
			if(inq[Adj[head][i]] == 0) {
				ans[Adj[head][i]] = maxNum;
				q.push(Adj[head][i]);
				inq[Adj[head][i]] = 1;
			}
		}
	}
	
}

int main(void) {
	scanf("%d%d", &n, &m);
	for(int i = 0; i < m; i++) {
		int id1, id2;
		scanf("%d%d", &id1, &id2);
		Adj[id2].push_back(id1);
	}
	
	for(int i = n; i > 0; i--) {
//		DFS(i, i);
		BFS(i, i);
	}
	for(int i = 1; i <= n; i++) {
		printf("%d ", ans[i]);
	}
	return 0;
}

出现的问题：

        1.这道题无论是的反向建边还是正常建边，dfs()都比bfs()快；

        2.bfs时，忘记被访问过的顶点，不能再进行访问了，在函数入口加个判断语句；

        3.bfs时，while循环中，满足条件的顶点，竟然忘记加入队列中；