方法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;
}