Recherche forêt BFS

Formation 5 - titre D

Une entreprise a n employés numérotés de 1 à n. Chaque employé a soit pas supérieur immédiat ou exactement un gestionnaire immédiat, qui est un autre employé avec un autre numéro. Un employé A est considéré comme le supérieur d'un autre employé B si au moins une des conditions suivantes est remplie:

Un employé est le supérieur immédiat de l' employé B
employé B a un employé supérieur immédiat C tel que A employé est le supérieur de l' employé C.

La Société ne sera pas un cycle de gestion. C'est, il n'y aura pas un employé qui existe est le supérieur de sa / son propre gestionnaire immédiat.
Aujourd'hui , l'entreprise va organiser une fête. Il revient à diviser tous les employés de n en plusieurs groupes: chaque employé doit appartenir à un seul groupe. En outre, dans un seul groupe, il ne doit pas être deux employés A et B tel que A est le supérieur de B.
Quel est le nombre minimum de groupes qui doivent être formés?

Contribution

La première ligne contient nombre entier n (1 ≤ n ≤ 2000) - le nombre d'employés.
Les lignes suivantes contiennent les n nombres entiers pi (1 ≤ pi ≤ n ou pi = -1). Chaque pi représente le supérieur immédiat de l'employé i-ème. Si pi est -1, cela signifie que le i-e employé ne dispose pas d' un gestionnaire immédiat.
Il est garanti, qu'aucun employé sera le supérieur immédiat de lui / elle - même (pi ≠ i). En outre, il y aura des cycles pas de gestion.

Production

Imprimer un entier indiquant le nombre minimum de groupes qui seront formés au sein du parti.

Exemples

Contribution

5
-1
1
2
1
-1

Production

3

Remarque

Pour le premier exemple, trois groupes sont suffisants, par exemple:

Employé 1
Employés 2 et 4
employés 3 et 5

#pragma warning (disable:4996)
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <cstring>
#include <string>
#include <cstdio>
#include <cmath>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#define inf 0X3f3f3f3f
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int N = 1e7 + 5;
const int maxn = 2e3 + 5;

int head[maxn], ver[maxn], nex[maxn];
int d[maxn];//深度
bool r[maxn];
int tot;

int ans = 0;

void add(int x, int y)
{
	tot++;
	ver[tot] = y;
	nex[tot] = head[x];
	head[x] = tot;
}

void bfs(int root)
{
	memset(d, 0, sizeof(d));
	queue<int> q;
	q.push(root);
	d[root] = 1;
	ans = max(ans, d[root]);
	while (q.size())
	{
		int x = q.front();
		q.pop();
		for (int i = head[x]; i; i = nex[i])
		{
			int y = ver[i];
			if (d[y])
				continue;
			d[y] = d[x] + 1;
			ans = max(ans, d[y]);
			q.push(y);
		}
	}
}

int main()
{
	int n;
	scanf("%d", &n);
	memset(r, 1, sizeof(r));
	for (int i = 1; i <= n; i++)
	{
		int p;
		scanf("%d", &p);
		if (p == -1)
			continue;
		add(p, i);
		r[i] = 0;
	}
	for (int i = 1; i <= n; i++)
		if (r[i] == 1)
			bfs(i);
	printf("%d\n", ans);
	return 0;
}

Idées:
BFS Traversal, la plus profonde profondeur enregistrée.