Codeforces 592D - Super M - [树的直径][DFS]

Time limit 2000 ms

Memory limit 262144 kB

Source Codeforces Round #328 (Div. 2)

Ari the monster is not an ordinary monster. She is the hidden identity of Super M, the Byteforces’ superhero. Byteforces is a country that consists of n cities, connected by n - 1 bidirectional roads. Every road connects exactly two distinct cities, and the whole road system is designed in a way that one is able to go from any city to any other city using only the given roads. There are m cities being attacked by humans. So Ari... we meant Super M have to immediately go to each of the cities being attacked to scare those bad humans. Super M can pass from one city to another only using the given roads. Moreover, passing through one road takes her exactly one kron - the time unit used in Byteforces.

However, Super M is not on Byteforces now - she is attending a training camp located in a nearby country Codeforces. Fortunately, there is a special device in Codeforces that allows her to instantly teleport from Codeforces to any city of Byteforces. The way back is too long, so for the purpose of this problem teleportation is used exactly once.

You are to help Super M, by calculating the city in which she should teleport at the beginning in order to end her job in the minimum time (measured in krons). Also, provide her with this time so she can plan her way back to Codeforces.

Input

The first line of the input contains two integers n and m (1 ≤ m ≤ n ≤ 123456) - the number of cities in Byteforces, and the number of cities being attacked respectively.

Then follow n - 1 lines, describing the road system. Each line contains two city numbers u_i and v_i (1 ≤ u_i, v_i ≤ n) - the ends of the road i.

The last line contains m distinct integers - numbers of cities being attacked. These numbers are given in no particular order.

Output

First print the number of the city Super M should teleport to. If there are many possible optimal answers, print the one with the lowest city number.

Then print the minimum possible time needed to scare all humans in cities being attacked, measured in Krons.

Note that the correct answer is always unique.

Example

Input

7 2
1 2
1 3
1 4
3 5
3 6
3 7
2 7

Output

2
3

Input

6 4
1 2
2 3
2 4
4 5
4 6
2 4 5 6

Output

2
4

Note

In the first sample, there are two possibilities to finish the Super M's job in 3 krons. They are:

 and .

However, you should choose the first one as it starts in the city with the lower number.

题意：

一棵树有n个节点，n-1条边；

在这棵树上有m个标记的节点，有个叫SpuerM的人要从某一个点出发走遍所有标记点；

问从哪个点走能使得走过路径长度最短，输出起点编号（若有多个点都能作为起点，选编号最小的）和该路径长度。

题解：

看完题，一看这棵树的规模，心里有底——大概就O(N)的算法可以过，再看是一棵树，若要利用树的性质去求节点间的距离，又只能用O(N)的算法……

瞬间想起有关树的直径和DFS，翻到之前的博文：http://www.cnblogs.com/dilthey/p/7231438.html

那么怎么样才能利用上树的直径的性质呢？

考虑我们可以从m个标记点中任选一个作为树根，DFS产生一棵“新树”，剥离那些不可能去走的节点和边；

然后就可以再用两次DFS求得这棵新树的直径；

（原本考虑用树形DP求直径，但是这样一来似乎无法求得直径的端点，就得不到答案要求的起点编号；

而如果用两次DFS的话，两次for循环遍历寻找endpoint的过程，可以保证寻找到的endpoint是编号最小的，就能同时求得树的直径长度和编号最小的直径端点，正好满足题目要求.）

AC代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn = ;

int n,m;
int newTreeEdgeNum;
bool attack[maxn],keep[maxn];

struct Edge{
    int u,v;
};
vector<Edge> E;
vector<int> G[maxn];
void addedge(int u,int v)
{
    E.push_back((Edge){u,v});
    E.push_back((Edge){v,u});
    int _size=E.size();
    G[u].push_back(_size-);
    G[v].push_back(_size-);
}

bool dfs(int now,int par)//返回now这个节点是否保留
{
    int _size=G[now].size();

    bool flag=;
    for(int i=;i<_size;i++)
    {
        Edge& e=E[G[now][i]]; int nxt=e.v;
        if(nxt==par) continue;
        if(dfs(nxt,now) && flag==) flag=;
    }
    keep[now]=(flag||attack[now]);

    if(keep[now] && par) newTreeEdgeNum++;
    return keep[now];
}

int dist[maxn];
void newTreeDFS(int now,int par)
{
    if(!keep[now]) return;
    for(int i=;i<G[now].size();i++)
    {
        Edge& e=E[G[now][i]]; int nxt=e.v;
        if(nxt==par || !keep[nxt]) continue;
        dist[nxt]=dist[now]+;
        newTreeDFS(nxt,now);
    }
}

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=,u,v;i<=n-;i++)
    {
        scanf("%d%d",&u,&v);
        addedge(u,v);
    }
    memset(attack,,sizeof(attack));
    int root=;
    for(int i=,tmp;i<=m;i++)
    {
        scanf("%d",&tmp);
        attack[tmp]=;
        if(root==) root=tmp;
    }

    memset(keep,,sizeof(keep));
    newTreeEdgeNum=;
    keep[root]=dfs(root,);

    /* 关于新树的debug
    for(int i=1;i<=n;i++) printf("attack[%d]=%d\n",i,attack[i]); //检查被攻击城市
    for(int i=1;i<=n;i++) printf("keep[%d]=%d\n",i,keep[i]); //检查新树保留节点
    printf("newTreeEdgeNum=%d\n\n",newTreeEdgeNum);
    */

    dist[root]=;
    newTreeDFS(root,);
    int endpoint1;
    for(int i=,maxi=-;i<=n;i++)
    {
        if(!keep[i]) continue;
        if(dist[i]>maxi)
        {
            maxi=dist[i];
            endpoint1=i;
        }
    }

    dist[endpoint1]=;
    newTreeDFS(endpoint1,);
    int endpoint2;
    for(int i=,maxi=-;i<=n;i++)
    {
        if(!keep[i]) continue;
        if(dist[i]>maxi)
        {
            maxi=dist[i];
            endpoint2=i;
        }
    }

    printf("%d\n",min(endpoint1,endpoint2));
    printf("%d\n",*newTreeEdgeNum-dist[endpoint2]);
}

PS.通过这道题，也算是把有关树的直径的问题好好巩固了一下，还是不错的！