Codeforces 239E World Eater Brothers【思维+树形Dp】

E. World Eater Brothers

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

You must have heard of the two brothers dreaming of ruling the world. With all their previous plans failed, this time they decided to cooperate with each other in order to rule the world.

As you know there are n countries in the world. These countries are connected by n - 1 directed roads. If you don't consider direction of the roads there is a unique path between every pair of countries in the world, passing through each road at most once.

Each of the brothers wants to establish his reign in some country, then it's possible for him to control the countries that can be reached from his country using directed roads.

The brothers can rule the world if there exists at most two countries for brothers to choose (and establish their reign in these countries) so that any other country is under control of at least one of them. In order to make this possible they want to change the direction of minimum number of roads. Your task is to calculate this minimum number of roads.

Input

The first line of input contains an integer n (1 ≤ n ≤ 3000). Each of the next n - 1 lines contains two space-separated integers ai and bi(1 ≤ ai, bi ≤ n; ai ≠ bi) saying there is a road from country ai to country bi.

Consider that countries are numbered from 1 to n. It's guaranteed that if you don't consider direction of the roads there is a unique path between every pair of countries in the world, passing through each road at most once.

Output

In the only line of output print the minimum number of roads that their direction should be changed so that the brothers will be able to rule the world.

Examples

input

4
2 1
3 1
4 1

output

1

input

5
2 1
2 3
4 3
4 5

output

0

题目大意：

给出N个点，N-1条边的有向图，保证图是在一个联通快中的，问改变最少的边的方向，使得选取两个点作为起点，可以走到其他所有点。

问最少边数。

思路：

①因为是找到两个点作为起点，而且整个整个图是一个联通块 ，那么我们考虑O（n-1）去枚举一条断边，将其隔开，然后就得到了两个分开的联通块，然后在每一个联通块中做一个子问题即可。

②那么对于一棵树的子问题，其实就是一个树形Dp，我们设定Dp【i】表示，以i为根节点，其到达子树中各个节点需要改变的边的个数。

那么不难写出其状态转移方程：Dp【u】+=Dp【v】+W（u，v），我们这里设定不改变方向的边权值为0，改变方向的反向边的权值为1即可。

③树型dp无异于两个方向，一个子树方向，一个非子树方向，那么再设定F【i】，表示以节点i为中心，到达非子树方向的各个节点的最小花费。

那么也不难写出其状态转移方程：

F【u】+=F【from】+W（u，from）【W（u，from）==1-W（from，u）】；

F【u】+=Dp【u】-Dp【v】-W（from，u）；

那么过程维护一下最优即可，时间复杂度O（n^2）；

Ac代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
using namespace std;
struct node
{
    int from,to,next,w;
}e[150000];
int output;
int xx[5000],yy[5000];
int head[5000];
int vis[5000];
int n,cont;
void add(int from,int to,int w)
{
    e[cont].to=to;
    e[cont].w=w;
    e[cont].next=head[from];
    head[from]=cont++;
}
/***********************************/
int dp[5000];
int f[5000];
void Dfs(int u,int from)
{
    vis[u]=1;
    for(int i=head[u];i!=-1;i=e[i].next)
    {
        int v=e[i].to;
        int w=e[i].w;
        if(v==from)continue;
        Dfs(v,u);
        dp[u]+=dp[v]+w;
    }
}
void dfs(int u,int from,int fromw)
{
    if(from!=-1)f[u]=f[from]+1-fromw;
    if(from!=-1)f[u]+=dp[from]-dp[u]-fromw;
    for(int i=head[u];i!=-1;i=e[i].next)
    {
        int v=e[i].to;
        int w=e[i].w;
        if(v==from)continue;
        dfs(v,u,w);
    }
}
/***********************************/
void Slove(int delnum)
{
    cont=0;
    memset(head,-1,sizeof(head));
    for(int i=1;i<=n-1;i++)
    {
        if(i==delnum)continue;
        else add(xx[i],yy[i],0),add(yy[i],xx[i],1);
    }
    memset(dp,0,sizeof(dp));
    memset(f,0,sizeof(f));
    memset(vis,0,sizeof(vis));
    for(int i=1;i<=n;i++)
    {
        if(vis[i]==0)
        {
            Dfs(i,-1);
            dfs(i,-1,0);
            break;
        }
    }
    int ans=0;
    int temp=0x3f3f3f3f;
    for(int i=1;i<=n;i++)
    {
        if(vis[i]==1)
        {
            vis[i]=2;
            temp=min(temp,f[i]+dp[i]);
        }
    }
    ans=temp;
    for(int i=1;i<=n;i++)
    {
        if(vis[i]==0)
        {
            Dfs(i,-1);
            dfs(i,-1,0);
            break;
        }
    }
    temp=0x3f3f3f3f;
    for(int i=1;i<=n;i++)
    {
        if(vis[i]==1)
        {
            vis[i]=2;
            temp=min(temp,f[i]+dp[i]);
        }
    }
    output=min(output,ans+temp);
}
int main()
{
    while(~scanf("%d",&n))
    {
        if(n==1)
        {
            printf("0\n");
            continue;
        }
        for(int i=1;i<=n-1;i++)
        {
            scanf("%d%d",&xx[i],&yy[i]);
        }
        output=0x3f3f3f3f;
        for(int i=1;i<=n-1;i++)
        {
            Slove(i);
        }
        printf("%d\n",output);
    }
}