poj1047(树形dp)

题目

转化下就是给出一棵树求最少要断掉多少条边才能分隔出一个有p个节点的子树

这道树形dp就相对难一点了，我写的中还用到了数组的滚动，整理出来方程即

f[root][j]=min{f2[root][j]+1,f2[root][k]+f[node][j-k]}

前面那部分，即把root->node这条边分隔开来

而后面那部分，即是前面保留k个结点，而以node为根的子树保留j-k个结点

这里循环完后，f[root][j]含义是以root为根的树中分隔出j个结点的以root为根的子树所需最少断边数

所以答案并非直接的f[troot][p],而是min{f[troot][p],f[tnode][p]+1} (若该子树根结点不是总的树的根节点，还需多分离

一个边)

代码如下：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Iterator;
import java.util.StringTokenizer;
import java.util.Vector;

class Reader{
	static BufferedReader reader;
	static StringTokenizer tokenizer;
	static void init(InputStream input) {
		reader=new BufferedReader(new InputStreamReader(input));
		tokenizer=new StringTokenizer("");
	}
	static String next() throws IOException{
		while (!tokenizer.hasMoreTokens()) {
			tokenizer=new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}
	static int nextInt() throws IOException{
		return Integer.parseInt(next());
	}
}
public class Main {

	/**
	 * @param args
	 */
	static int n,p,u,v,root,ans;
	static Vector<Integer> vector[];
	static boolean nroot[];
	static int depth[],size[];
	static int f[][],f2[][];
	private static int getmin(int a,int b) {
		return a<b?a:b;
	}
	private static void dfs(int u,int dep) {
		Iterator<Integer> iter=vector[u].iterator();
		if (dep==1) depth[u]=0;
		else depth[u]=1;
		int node;
		int psize=1;
		size[u]=1;
		f[u][1]=0;
		while (iter.hasNext()) {
			node=iter.next();
			psize=size[u];
			dfs(node,dep+1);
			size[u]+=size[node];
			for (int i=1;i<=psize;i++)
				f2[u][i]=f[u][i];
			for (int i=1;i<=size[u];i++) {
				f[u][i]=n+1;
				if (i<=psize) f[u][i]=f2[u][i]+1;
				for (int k=1;k<=i-1;k++)
					if ((k<=psize)&(i-k<=size[node]))
						f[u][i]=getmin(f[u][i],f2[u][k]+f[node][i-k]);
				//System.out.println(u+" "+i+" "+node+" "+f[u][i]);
			}
		}
	}
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
      Reader.init(System.in);
      n=Reader.nextInt();
      p=Reader.nextInt();
      vector=new Vector[n+1];
      size=new int[n+1];
      nroot=new boolean[n+1];
      depth=new int[n+1];
      for (int i=1;i<=n;i++)
    	  vector[i]=new Vector<Integer>();
      for (int i=1;i<=n-1;i++) {
    	  u=Reader.nextInt();
    	  v=Reader.nextInt();
    	  vector[u].add(v);
    	  nroot[v]=true;
      }
      for (int i=1;i<=n;i++)
    	  if (!nroot[i]) {
    		  root=i;
    		  break;
    	  }
      f=new int[n+1][n+1];
      f2=new int[n+1][n+1];
      dfs(root,1);
      ans=n+1;
      for (int i=1;i<=n;i++)
    	  if (size[i]>=p) 
    		  ans=getmin(ans,f[i][p]+depth[i]);
      System.out.println(ans);
	}

}