Codeforces Round #148 (Div. 2) E. World Eater Brothers（思维+树形dp）

E. World Eater Brothers

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

题意：

        一颗“有向”树中选两个点，使得该两点加起来能到达其它所有点，

且需要反转的边最少。

思路：

      首先自己对树形dp不熟，其次题解是通过枚举边来枚举两个子树，

然后分别在2棵子树上dp。

题解描述：

①因为是找到两个点作为起点，而且整个整个图是一个联通块 ，那么我们考虑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）；

代码实现：

#include<iostream>
#include<cstring>
#include<cmath>
#include<queue>
#include<map>
#include<cstdio>
#include<algorithm>
#define LL long long
#define INF 0x3f3f3f3f
using namespace std;
const int N=3000+100;
const int M=6e3+100;
const  int mod=1e9+9;
int head[N],Next[M],tot,ver[M],edge[M];
void add(int x,int y,int v) {
	ver[++tot]=y;
	edge[tot]=v;
	Next[tot]=head[x];
	head[x]=tot;
}
int dpb[N],dpf[N];
void sol1(int x,int pre,int flag) {//子树 

	for(int i=head[x]; i; i=Next[i]) {
		int y=ver[i];
		if(y==pre||y==flag)continue;
		sol1(y,x,flag);
		dpb[x]+=dpb[y]+(1-edge[i]);
	}
}
int tmp;
void sol2(int x,int pre,int flag) {//非子树 
	if(pre==-1)dpf[x]=0;
	else {
		dpf[x]+=dpf[ver[pre^1]]+dpb[ver[pre^1]]+(edge[pre]==0?-1:1)-dpb[x];
	}
	tmp=min(tmp,dpf[x]+dpb[x]);
	for(int i=head[x]; i; i=Next[i]) {
		int y=ver[i];
		if(i==(pre^1)||y==flag)continue;
		sol2(y,i,flag);
	}
}
int main() {
#ifdef MYHOME
	freopen("input.txt","r",stdin);
#endif
	int n,x,y,mini,ans;
	while(cin>>n) {
		tot=1;
		ans=mini=INF;
		
		memset(head,0,sizeof(head));
		memset(ver,0,sizeof(ver));
		memset(Next,0,sizeof(Next));
		memset(edge,0,sizeof(edge));

		for(int i=1; i<=n-1; i++) {
			cin>>x>>y;
			add(x,y,1);
			add(y,x,0);
		}

		for(int i=2; i<=tot; i+=2) {
			y=ver[i];
			x=ver[i^1];
			memset(dpf,0,sizeof(dpf));
			memset(dpb,0,sizeof(dpb));
			sol1(x,-1,y);
			sol1(y,-1,x);
			tmp=INF;
			sol2(x,-1,y);
			mini=tmp;
			tmp=INF;
			sol2(y,-1,x);
			mini+=tmp;
			ans=min(ans,mini);
		}
		if(ans>=INF)ans=0;
		cout<<ans<<endl;
	}
	return 0;
}

THE END；