hdu5452
转自
因为生成树中只有一条边属于割集，那么割对生成树来说只是分成了两个子树，那么就考虑割生成树上割哪条边是最优的。
首先对生成树进行建树剖，对于每条非树边的两个端点u和v，对 u –> v 在生成树上的简单路径上的边权值加一，最后找到所有边权值最小的边，就是属于最小割的边。
所有对找到的这条边的权值做贡献的边，一定是跨越了以这条边分开的两个子树，即如果要分开这两个子树，这些边也要割掉，这些边就是要求的最小割集。
这题卡常数，所以路径上边权加一的操作不能用线段树或者树状数组来更新，因为是操作完成后才对边权进行遍历，所以可以用差分前缀和来计算每条边被更新了几次。
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.NavigableSet;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Set;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeSet;
public class Main {
public static void main(String[] args) throws IOException{
StreamTokenizer cin = new StreamTokenizer(new BufferedInputStream(System.in));
InputReader in = new InputReader(System.in) ;
PrintWriter out = new PrintWriter(System.out) ;
int t = in.nextInt() ;
for(int i = 1 ; i <= t ; i++){
out.print("Case #" + i + ": ");
new Task().solve(in, out) ;
}
out.flush();
}
}
class Task{
public void solve(InputReader in , PrintWriter out) throws IOException{
int j , u , v , k , t , T = 1 , m , d ;
n = in.nextInt() ;
m = in.nextInt() ;
init() ;
for(int i = 1 ; i < n ; i++){
u = in.nextInt() ;
v = in.nextInt() ;
addedge(u , v) ;
}
dfs1(1 , 0 , 0) ;
dfs2(1 , 1) ;
for(int i = 1 ; i <= m - n + 1 ; i++){
u = in.nextInt() ;
v = in.nextInt() ;
if(tid[u] < tid[v]){
u ^= v ; v ^= u ; u ^= v ;
}
change2(u , v , 1) ;
}
gsum2() ;
long res = ans2[2] ;
for(int i = 2 ; i <= n ; i++) res = Math.min(res , ans2[i]) ;
out.println(res+1) ;
}
static final int maxn = 20008 ;
static long[] c1 = new long[maxn] ;
static long[] c2 = new long[maxn] ;
static long[] ans1 = new long[maxn] ;
static long[] ans2 = new long[maxn] ;
int n ;
static int[] siz = new int[maxn] ;
static int[] top = new int[maxn] ;
static int[] son = new int[maxn] ;
static int[] dep = new int[maxn] ;
static int[] tid = new int[maxn] ;
static int[] fa = new int[maxn] ;
static int[] rank = new int[maxn] ;
static int[] head = new int[maxn] ;
static int[] to = new int[200008*2] ;
static int[] next = new int[200008*2] ;
int edge ;
int tim ;
void init(){
Arrays.fill(head, -1) ;
Arrays.fill(son, -1) ;
Arrays.fill(c2, 0) ;
tim = edge = 0 ;
}
void addedge(int u , int v){
to[edge] = v ; next[edge] = head[u] ; head[u] = edge++ ;
to[edge] = u ; next[edge] = head[v] ; head[v] = edge++ ;
}
void dfs1(int u , int father , int d){
dep[u] = d ;
fa[u] = father ;
siz[u] = 1 ;
for(int i = head[u] ; i != -1 ; i = next[i]){
int v = to[i] ;
if(v != father){
dfs1(v , u , d+1) ;
siz[u] += siz[v] ;
if(son[u] == -1 || siz[v] > siz[son[u]]) son[u] = v ;
}
}
}
void dfs2(int u , int tp){
top[u] = tp ;
tid[u] = ++tim ;
rank[tid[u]] = u ;
if(son[u] == -1) return ;
dfs2(son[u] , tp) ;
for(int i = head[u] ; i != -1 ; i = next[i]){
int v = to[i] ;
if(v != son[u] && v != fa[u]) dfs2(v , v) ;
}
}
void in1(int l , int r , int c){
c1[l] += c ;
c1[r+1] -= c ;
}
void gsum1(){
long t = 0 ;
for(int i = 1 ; i <= n ; i++){
t += c1[i] ;
ans1[i] = t ;
}
}
void in2(int l , int r , int c){
c2[l] += c ;
c2[r+1] -= c ;
}
void gsum2(){
long t = 0 ;
for(int i = 1 ; i <= n ; i++){
t += c2[i] ;
ans2[i] = t ;
}
}
void change2(int x , int y , int d){
while(top[x] != top[y]){
if(dep[top[x]] < dep[top[y]]){
x ^= y ; y ^= x ; x ^= y ;
}
in2(tid[top[x]] , tid[x] , d) ;
x = fa[top[x]] ;
}
if(x == y) return ;
if(dep[x] > dep[y]){
x ^= y ; y ^= x ; x ^= y ;
}
in2(tid[x]+1 , tid[y] , d) ;
}
void change1(int x , int y , int d){
while(top[x] != top[y]){
if(dep[top[x]] < dep[top[y]]){
x ^= y ; y ^= x ; x ^= y ;
}
in1(tid[top[x]] , tid[x] , d) ;
x = fa[top[x]] ;
}
if(dep[x] > dep[y]){
x ^= y ; y ^= x ; x ^= y ;
}
in1(tid[x] , tid[y] , d) ;
}
}
class InputReader{
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream){
reader = new BufferedReader(new InputStreamReader(stream), 32768) ;
tokenizer = null ;
}
public String next(){
while(tokenizer == null || ! tokenizer.hasMoreTokens()){
try{
tokenizer = new StringTokenizer(reader.readLine());
}catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt(){
return Integer.parseInt(next());
}
public long nextLong(){
return Long.parseLong(next());
}
public double nextDouble(){
return Double.parseDouble(next());
}
}