HDU5758 Explorer Bo 树形dp

我是参考这一篇写的：http://blog.csdn.net/fsss_7/article/details/52049474

一点感想：dp[i][0]代表以这个点为根的且总叶子数为偶数个叶子的答案

考虑每条树边的贡献，贪心的想，肯定是每条树边出现的次数越少越好

由于树链肯定从一个叶子到另外一个叶子的，那么可以想到

1：考虑每条树边下面的子树，如果有奇数个节点，那么出来一条边就可以了，剩下的自己匹配就好

2：如果是偶数条边，出来两条就行了，如果多余两条不如两条更优，少于两条，不符合题意

dp[i][1]代表总点数为奇数时，以i为根的子树，包含一条链的最优答案

奇数比偶数实际上就多了，一条链，考虑包含这条链

贪心的想，这条链只要从一个叶子节点延伸到它的第一个祖先（且这个祖先的有大于一个儿子）就行了

dp[i][1]就是当前子树包含这条链的最优值，那么dp[root][1]就是奇数的答案，dp[root][0]就是偶数的答案

#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#include <map>
#include <iostream>
#include <algorithm>
using namespace std;
typedef  long long LL;
const int N=1e5+;
const int INF=0x3f3f3f3f;
int T,n,head[N],tot;
struct Edge{
  int v,next;
}edge[N<<];
void add(int u,int v){
  edge[tot].v=v;
  edge[tot].next=head[u];
  head[u]=tot++;
}
int d[N],son[N],dp[N][];
void dfs(int u,int f){
  int child=;son[u]=;dp[u][]=;
  for(int i=head[u];~i;i=edge[i].next){
     int v=edge[i].v;if(v==f)continue;
     dfs(v,u);++child;son[u]+=son[v];
     dp[u][]+=dp[v][];
     if(son[v]&)++dp[u][];
     else dp[u][]+=;
  }
  for(int i=head[u];~i;i=edge[i].next){
    int v=edge[i].v;if(v==f)continue;
    if(child>&&son[v]==)
      dp[u][]=min(dp[u][],dp[u][]);
    if(dp[v][]==INF)continue;
    int d = ((son[v] & ) ?  : -);
    dp[u][] = min(dp[u][], dp[u][] - dp[v][] + dp[v][] + d);
  }
  if(!child)son[u]=;
}
int main(){
  scanf("%d",&T);
  while(T--){
    scanf("%d",&n);tot=;
    memset(head,-,sizeof(head));
    memset(dp,INF,sizeof(dp));
    memset(d,,sizeof(d));
    for(int i=;i<n;++i){
      int u,v;scanf("%d %d",&u,&v);
      add(u,v);add(v,u);++d[u];++d[v];
    }
    if(n==){printf("1\n");continue;}
    int cnt=,root;
    for(int i=;i<=n;++i)
      if(d[i]!=)root=i;
      else ++cnt;
    dfs(root,);
    if(cnt&)printf("%d\n",dp[root][]);
    else printf("%d\n",dp[root][]);
  }
  return ;
}