POJ 1848 Tree

Tree

Time Limit: 1000MS		Memory Limit: 30000K
Total Submissions: 2564		Accepted: 859

Description

Consider a tree with N vertices, numbered from 1 to N. Add, if it is possible, a minimum number of edges thus every vertex belongs to exactly one cycle.

Input

The input has the following structure: 
N 
x(1) y(1) 
x(2) y(2) 
... 
x(N-1) y(n-1) 
N (3 <= N <=100) is the number of vertices. x(i) and y(i) (x(i), y(i) are integers, 1 <= x(i), y(i) <= N) represent the two vertices connected by the i-th edge. 

Output

The output will contain the value -1 if the problem doesn't have a solution, otherwise an integer, representing the number of added edges.

Sample Input

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

Sample Output

2

Source

Romania OI 2002

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define INF 100

#define MAXN 110
#define MAXE 220
struct LEdge{
	int ed, next;
}edge[MAXE];
int head[MAXN], nEdge;

void init(){
	nEdge = 0;
	memset(head, 0xff, sizeof(head));
}

void addEdge(int i, int j){
	edge[nEdge].ed = j;
	edge[nEdge].next = head[i];
	head[i] = nEdge++;
}

int f[MAXN][3];

int imin(int a, int b){
	if (a < 0) return b;
	if (b < 0) return a;
	return a < b ? a : b;
}

int dfs(int pre, int cur){
	int i, j, k, p, q, sum;
	sum = 0;
	for (i = head[cur]; i != -1; i = edge[i].next){
		k = edge[i].ed;
		if (k == pre) continue;
		if (!dfs(cur, k)) return 0;
		sum += f[k][0];
	}
	f[cur][0] = f[cur][1] = f[cur][2] = INF;
	f[cur][1] = sum;
	for (i = head[cur]; i != -1; i = edge[i].next){
		p = edge[i].ed;
		if (p == pre) continue;
		f[cur][0] = imin(f[cur][0], f[p][2] - f[p][0] + sum + 1);
		f[cur][2] = imin(f[cur][2], f[p][2] - f[p][0] + sum);
		f[cur][2] = imin(f[cur][2], f[p][1] - f[p][0] + sum);
		for (j = edge[i].next; j != -1; j = edge[j].next){
			q = edge[j].ed;
			if (q == pre) continue;
			f[cur][0] = imin(f[cur][0], f[p][1] - f[p][0] + f[q][1] - f[q][0] + sum + 1);
			f[cur][0] = imin(f[cur][0], f[p][2] - f[p][0] + f[q][1] - f[q][0] + sum + 1);
			f[cur][0] = imin(f[cur][0], f[p][1] - f[p][0] + f[q][2] - f[q][0] + sum + 1);
			f[cur][0] = imin(f[cur][0], f[p][2] - f[p][0] + f[q][2] - f[q][0] + sum + 1);			
		}
	}
//	printf("cur = %d, f[0] = %d, f[1] = %d, f[2] = %d, t = %d, p = %d, q = %d, r = %d\n", cur, f[cur][0], f[cur][1], f[cur][2], t, p, q, r);
	if (f[cur][0] >= INF && f[cur][1] >= INF && f[cur][2] >= INF)
		return 0;
	return 1;
}

int main(){
	int i, j, k, n;
	while(scanf("%d", &n) != EOF){
		init();
		for (k = 1; k < n; k++){
			scanf("%d%d", &i, &j);
			addEdge(i, j);
			addEdge(j, i);
		}
		if (!dfs(0, 1) || f[1][0] >= INF) f[1][0] = -1;
		printf("%d\n", f[1][0]);
	}	
	return 0;
}

/*
f[i][0] i及其以下已成环
f[i][1] 仅i没成环
f[i][2] i带着一个长至少为2的链

f[i][0] = min(
	f[p][1] + f[q][1] + sum(f[其他][0]) + 1, 
	f[p][2] + f[q][1] + sum(f[其他][0]) + 1, 
	f[p][1] + f[q][2] + sum(f[其他][0]) + 1, 
	f[p][2] + f[q][2] + sum(f[其他][0]) + 1, 
	f[p][2] + sum(f[其他][0]) + 1)
f[i][1] = sum(f[其他][0])
f[i][2] = min(
	f[p][2] + sum(f[其他][0]),
	f[p][1] + sum(f[其他][0]))

开始无效值是-1，虽然做了好多好多特判
例如，有的子树本身无法全部成环，这样的点如果有一个，
可以通过和当前点组成环，或者和其他链组成环，或者作为当前点的链
如果有两个，则必须把他俩连一块
如果多于两个，说明无解
但是都WA掉了
后来看了网上的，没那么多特判，枚举起来也特暴力
初值设的INF，于是改成比较暴力的二重循环，而不是一重去找，
写的简单了，也就过了
经验: 尽量简洁，卡住了就释放些暴力	
*/