浙大 PAT Advanced level 1021. Deepest Root (25)

A graph which is connected and acyclic can be considered a tree. The height of the tree depends on the selected root. Now you are supposed to find the root that results in a highest tree. Such a root is called the deepest root.

Input Specification:

Each input file contains one test case. For each case, the first line contains a positive integer N (<=10000) which is the number of nodes, and hence the nodes are numbered from 1 to N. Then N-1 lines follow, each describes an edge by given the two adjacent
nodes' numbers.

Output Specification:

For each test case, print each of the deepest roots in a line. If such a root is not unique, print them in increasing order of their numbers. In case that the given graph is not a tree, print "Error: K components" where K is the number of connected components
in the graph.

Sample Input 1:

5

1 2

1 3

1 4

2 5

Sample Output 1:

3

4

5

Sample Input 2:

5

1 3

1 4

2 5

3 4

Sample Output 2:

Error: 2 components

将不含环的图作为一颗树，求让树高度最大的所有根节点。求树的高度很明显可以用bfs。

可以遍历图的每一个节点求高度，然后输出所有高度最大的节点。但需要注意case中有许多稀疏图，只有用邻接表的方式才可以通过所有case，用二维数组表示树在遍历过程中会超时。

实际上更简单的想法是，首先选取任一一个节点做bfs，并记录下使得树高度最高的所有顶点的集合set1，然后从set1中任选一点做bfs，记录下所有使得树高度最高的顶点结合set2，set1和set2的并集即为最终的结果。

/*
可以AC，效率很高
0	答案正确	1	256	13/13
1	答案正确	1	296	2/2
2	答案正确	2	304	5/5
3	答案正确	23	1536	2/2
4	答案正确	1	256	2/2
5	答案正确	1	256	1/1
*/

#include <iostream>
#include <vector>
#include <queue>
#include <set>
using namespace std;

const int white = 0;
const int gray = 1;
const int black = 2;
typedef struct node
{
int color;
int height;
vector<int> adj;
}node;
int N;
vector<node> graph;

void dfs(int index)
{
int k;
graph[index].color = gray;
for (unsigned int i = 0; i < graph[index].adj.size(); ++i)
{
k = graph[index].adj[i];
if (white == graph[k].color)
{
dfs(k);
}
}
graph[index].color = black;
}

void bfs(int root, vector<int> &res)
{
int max_height = 0;
int index;
int k;
queue<int> nq;

for (int i = 0; i != N; ++i)
{
graph[i].color = white;
graph[i].height = 0;
}

nq.push(root);
graph[root].color = gray;
while (!nq.empty())
{
index = nq.front();
nq.pop();
graph[index].color = black;
for (unsigned int i = 0; i != graph[index].adj.size(); ++i)
{
k = graph[index].adj[i];
if (white == graph[k].color)
{
graph[k].height = graph[index].height + 1;
graph[k].color = gray;
nq.push(k);
if (graph[k].height > max_height)
{
max_height = graph[k].height;
}
}
}
}

for (int i = 0; i != N; ++i)
{
if (graph[i].height == max_height)
{
res.push_back(i);
}
}
return ;
}

int main()
{
int ni, nj;
vector<int> res1, res2;
set<int> res_all;
int parts = 0;
bool flag = false;

cin >> N;
graph.resize(N);
for (int i = 0; i != N; ++i)
{
graph[i].color = white;
graph[i].height = 0;
}

for (int i = 0; i != N-1; ++i)
{
cin >> ni >> nj;
--ni;
--nj;
graph[ni].adj.push_back(nj);
graph[nj].adj.push_back(ni);
}

for (int i = 0; i != N; ++i)
{
if (white == graph[i].color)
{
dfs(i);
++parts;
}
}

if (1 != parts)
{
cout << "Error: " << parts << " components" << endl;
return 0;
}

bfs(0, res1);
bfs(res1.at(0), res2);
ni = nj = 0;

for (unsigned int i = 0; i != res1.size(); ++i)
{
res_all.insert(res1[i]);
}
for (unsigned int i = 0; i != res2.size(); ++i)
{
res_all.insert(res2[i]);
}
for (set<int>::const_iterator iter = res_all.begin(); iter != res_all.end(); ++iter)
{
cout << (*iter)+1 << endl;
}

return 0;
}

/* 可以ac
0	答案正确	1	256	13/13
1	答案正确	1	256	2/2
2	答案正确	1	300	5/5
3	答案正确	984	1212	2/2
4	答案正确	1	256	2/2
5	答案正确	1	316	1/1
*/
/* 稀疏图用邻接表效率更高*/
#if 0
#include <iostream>
#include <vector>
#include <queue>
using namespace std;

const int white = 0;
const int gray = 1;
const int black = 2;
typedef struct node
{
int color;
int start;
int finish;
int height;
vector<int> adj;
}node;
int N;
vector<node> graph;
int ntime = 0;
int parts = 0;

void dfs(int index)
{
int k;
graph[index].color = gray;
graph[index].start = ntime++;
for (unsigned int i = 0; i < graph[index].adj.size(); ++i)
{
k = graph[index].adj[i];
if (white == graph[k].color)
{
dfs(k);
}
}
graph[index].color = black;
graph[index].finish = ntime++;
}

int bfs(int root)
{
int ret = 0;
int index;
int k;
queue<int> nq;

for (int i = 0; i != N; ++i)
{
graph[i].color = white;
graph[i].height = 0;
}

nq.push(root);
graph[root].color = gray;
while (!nq.empty())
{
index = nq.front();
nq.pop();
graph[index].color = black;
for (unsigned int i = 0; i != graph[index].adj.size(); ++i)
{
k = graph[index].adj[i];
if (white == graph[k].color)
{
graph[k].height = graph[index].height + 1;
graph[k].color = gray;
nq.push(k);
if (graph[k].height > ret)
{
ret = graph[k].height;
}
}
}
}
return ret;
}

int main()
{
int ni, nj, nh;
int max_height = 0;
vector<int> results;

cin >> N;
graph.resize(N);
for (int i = 0; i != N; ++i)
{
graph[i].color = white;
graph[i].height = 0;
}
for (int i = 0; i != N-1; ++i)
{
cin >> ni >> nj;
--ni;
--nj;
graph[ni].adj.push_back(nj);
graph[nj].adj.push_back(ni);
}

for (int i = 0; i != N; ++i)
{
if (white == graph[i].color)
{
dfs(i);
++parts;
}
}

if (1 != parts)
{
cout << "Error: " << parts << " components" << endl;
}
else
{
for (int i = 0; i != N; ++i)
{
/************************************************************************/
/* 注释掉下面的if 语句可以ac											*/
/* 考虑输入:2 1 2														*/
/************************************************************************/
/* if (graph[i].start + 1 == graph[i].finish) */
{
nh = bfs(i);
if (nh > max_height)
{
max_height = nh;
results.clear();
results.push_back(i);
}
else
{
if (nh == max_height)
{
results.push_back(i);
}
}
}
}

for (unsigned int i = 0; i != results.size(); ++i)
{
cout << results[i]+1 << endl;
}
}

return 0;
}

#endif

#if 0
// 超时
#include <iostream>
#include <queue>
using namespace std;

int graph[10002][10002];				/* 1表示存在路径*/
int visited[10002];						/* 1为已经访问*/
int result[10002];

void DFS(int root, int num)
{
visited[root] = true;
for (int i = 1; i <= num; ++i)
{
if (1 == graph[root][i] && 0 == visited[i])
{
DFS(i, num);
}
}
}

// 返回正值表示以root为根的树的最大深度
// 返回负值表示图有多少个不连通的部分
int levelCount(int root, int num)
{
int level;						// 记录以root为根的树的最大深度
int part;						// 记录图有多少个相互不连通的区域(针对"Error: K components")
bool flag = true;				// 如果是连通图, 则为true; 反之为false
int count, temp;
queue<int> Q;
for (int i = 1; i <= num; ++i)
{
visited[i] = 0;
}

Q.push(root);
count = 1;
level = 0;
visited[root] = 1;
part = 1;

while(!Q.empty())
{
while(count--)
{
temp = Q.front();
Q.pop();
for (int i = 1; i <= num; ++i)
{
if (1 == graph[temp][i] && 0 == visited[i])
{
visited[i] = 1;
Q.push(i);
}
}
}
count = Q.size();
++level;
}
for (int i = 1; i <= num; ++i)
{
// 存在未被访问的点
if (0 == visited[i])
{
flag = false;
DFS(i, num);
++part;
}
}
if (flag)
{
return level;
}
else
{
return -part;
}
}

int main()
{
int num;
int row, col;
int maxlevel = 0;
cin >> num;
for (int i = 1; i != num; ++i)
{
cin >> row >> col;
graph[row][col] = graph[col][row] = 1;
}
for (int i = 1; i <= num; ++i)
{
result[i] = levelCount(i, num);
if (result[i] < 0)
{
cout << "Error: " << -result[i] <<  " components" << endl;
system("pause");
return 0;
}
if (result[i] > maxlevel)
{
maxlevel = result[i];
}
}

for (int i = 1; i <= num; ++i)
{
if (result[i] == maxlevel)
{
cout << i << endl;
}
}

system("pause");
return 0;
}

#endif