1094 The Largest Generation （25 分）

最新推荐文章于 2024-06-02 16:33:44 发布

SYaoJun

最新推荐文章于 2024-06-02 16:33:44 发布

阅读量231

点赞数

CC 4.0 BY-SA版权

分类专栏： BFS DFS PAT甲级真题题解

本文链接：https://blog.youkuaiyun.com/SYaoJun/article/details/87103132

PAT甲级真题题解同时被 3 个专栏收录

137 篇文章

订阅专栏

DFS

68 篇文章

订阅专栏

BFS

27 篇文章

订阅专栏

本文介绍了四种不同的算法来解决树的最大宽度及其所在的层级问题，包括宽度优先搜索（BFS）、深度优先搜索（DFS）及两种变体。通过对比不同算法的实现方式，深入解析了树遍历的核心思想。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

方法1

根据六度空间这道题改变而成，具体请参照六度空间题解
注意：
当n为1时需要特殊处理，后面的方法2和方法3不需要。

#include<cstdio>
#include<queue>
#include<cstring>
#include<vector>
using namespace std;
const int maxn = 105;
int n,total=0,layer=0;
vector<int> T[maxn];

void BFS(int x){
	queue<int> q;
	q.push(x);
	int end=1,start=1,last=x,tail,Layer=1;
	while(!q.empty()){
		int temp = q.front();
		q.pop();
		for(int i=0;i<T[temp].size();i++){
			{
				q.push(T[temp][i]);
				tail = T[temp][i];
				end++;
			}
		}
		if(temp == last){
			last = tail;
			Layer++;
			if(end-start > total){
				total = end-start;
				layer = Layer;
			}
			start=end;
		}	
	}
}

int main(){
	int m,u,v,dad,k,son;
	scanf("%d%d",&n,&m);
	while(m--){   //建树 
		scanf("%d%d",&dad,&k);
		for(int i=0;i<k;i++){
			scanf("%d",&son);
			T[dad].push_back(son);
		}
	}
	if(n==1){
		printf("1 1\n");
		return 0;
	}
	BFS(1);
	printf("%d %d\n",total,layer);
	return 0;
}

方法2

使用DFS深度优先搜索
树使用简洁的静态写法

#include<cstdio>
#include<queue>
#include<cstring>
#include<vector>
using namespace std;
const int maxn = 105;
int n;
vector<int> T[maxn];
int hashT[maxn];


void DFS(int index, int level){
	hashT[level]++;  //该层的数量加1
	for(int i=0;i<T[index].size();i++){
		DFS(T[index][i], level + 1);
	} 
}

int main(){
	int m,u,v,dad,k,son;
	scanf("%d%d",&n,&m);
	while(m--){   //建树 
		scanf("%d%d",&dad,&k);
		for(int i=0;i<k;i++){
			scanf("%d",&son);
			T[dad].push_back(son);
		}
	}
	memset(hashT,0,sizeof(hashT));
	DFS(1,1);
	int maxValue=-1,layer;
	for(int i=1;i<maxn;i++){
		if(hashT[i] > maxValue){
			maxValue = hashT[i];
			layer = i;
		}
	}
	printf("%d %d\n",maxValue,layer);
	return 0;
}

方法3

使用BFS广度优先搜索
树使用另一种静态写法

#include<cstdio>
#include<queue>
#include<cstring>
#include<vector>
using namespace std;
const int maxn = 105;
int n;
int hashT[maxn];

struct node{
	int layer;
	vector<int> child;
}T[maxn];


void BFS(int index,int level){
	hashT[level]++;  //该层的数量加1
	T[index].layer=level;
	queue<int> q;
	q.push(index);
	while(!q.empty()){
		int temp = q.front();
		q.pop();
		for(int i=0;i<T[temp].child.size();i++){
			int child=T[temp].child[i];
			T[child].layer = T[temp].layer + 1;
			hashT[T[child].layer]++;
			q.push(child);
		}
	}
}

int main(){
	int m,u,v,dad,k,son;
	scanf("%d%d",&n,&m);
	while(m--){   //建树 
		scanf("%d%d",&dad,&k);
		for(int i=0;i<k;i++){
			scanf("%d",&son);
			T[dad].child.push_back(son);
		}
	}
	memset(hashT,0,sizeof(hashT));
	BFS(1,1);
	int maxValue=-1,layer;
	for(int i=1;i<maxn;i++){
		if(hashT[i] > maxValue){
			maxValue = hashT[i];
			layer = i;
		}
	}
	printf("%d %d\n",maxValue,layer);
	return 0;
}

方法4

#include <cstdio>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
#include <cstring>
#include <algorithm> 
#include <set>
#include <unordered_map>
#include <queue>
#include <cmath>
#include <cctype>
#include <queue>
using namespace std;
const int N = 105;
vector<int> G[N];
int opt = -1, level;
void bfs(){
	queue<int> q;
	q.push(1);
	int l = 1;
	while(q.size()){
		int len = q.size();
		if(len > opt) {
			opt = len;
			level = l;
		}
		l++;
		for(int i = 0; i < len; i++){
			int t = q.front();
			q.pop();
			for(int j = 0 ; j < G[t].size(); j++){
				q.push(G[t][j]);
			}
		}
	}
}
int main(){
	int n, m, k, x, u;
	scanf("%d%d", &n, &m);
	while(m--){
		scanf("%d %d", &u, &k);
		for(int i = 0; i < k; i++){
			scanf("%d", &x);
			G[u].push_back(x);
		}
	}
	bfs();
	printf("%d %d\n", opt, level); 
	return 0;
}