UVa 1218 Perfect Service 完美的服务

***状态设计值得一看
dp[u][0]表示u是服务器(以下v均指任意u的子结点,son指u的所有子结点)
ap[u][0]=sum{dp[v][1]}+1//错误，服务器是可以和其他服务器相邻的
dp[u][0]=sum{min(dp[v][0],dp[v][1])}+1
dp[u][1]表示u不是服务器，但是父亲是，显然子结点不是
dp[u][1]=sum{dp[v][2]}
dp[u][2]表示u和父亲都不是服务器，但自身有一个子结点是
此情况-1表示不可能满足
***dp[u][2]=min{dp[v][0]}//错误，别犯傻，怎么能忽略其他子结点需要的服务器
dp[u][2]=min{dp[v][0]+sum{dp[x][2]}}(x∈son-i)
=sum{dp[v][2]}-max{dp[v][2]-dp[v][0]}
=dp[u][1]+min{dp[v][0]-dp[v][2]}
（以上"表示..."均指"表示...的情况总数"）

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 int dp[][];
 bool vis[];
 //int vis2[20010];
 struct Edge
 {
     int to,next;
 }edge[];
 int num_edge,n,first[];
 //void dfs(int x)
 //{
 //    int k=first[x];
 //    while(k!=0)
 //    {
 //        if(vis2[k]==0)
 //        {
 //            vis2[k]=1;
 //            vis2[edge[k].p]=-1;
 //            dfs(edge[k].to);
 //        }
 //        k=edge[k].next;
 //    }
 //}
 void dfs2(int u)
 {
     vis[u]=true;
     dp[u][]=;
     dp[u][]=;
     int k=first[u],v;
     while(k!=)
     {
         v=edge[k].to;
         if(!vis[v])
         {
             dfs2(v);
             dp[u][]+=min(dp[v][],dp[v][]);
             dp[u][]+=dp[v][];
             dp[u][]=min(dp[u][],dp[v][]-dp[v][]);
         }
         k=edge[k].next;
     }
     dp[u][]+=dp[u][];
 }
 //void print(int x)
 //{
 //    printf("%d ",x);
 //    int k=first[x];
 //    while(k!=0)
 //    {
 //        if(vis2[k]==1)
 //        {
 //            print(edge[k].to);
 //        }
 //        k=edge[k].next;
 //    }
 //}
 int main()
 {
     int t,i,a,b;
     while(n!=-)
     {
         scanf("%d",&n);
         num_edge=;
         memset(vis,,sizeof(vis));
         memset(first,,sizeof(first));
         memset(dp,0x01,sizeof(dp));
         for(i=;i<n;i++)
         {
             scanf("%d%d",&a,&b);
             edge[++num_edge].to=b;
             edge[num_edge].next=first[a];
             first[a]=num_edge;
             //edge[num_edge].p=num_edge+1;
             edge[++num_edge].to=a;
             edge[num_edge].next=first[b];
             first[b]=num_edge;
             //edge[num_edge].p=num_edge-1;
         }
         //dfs(1);
         //print(1);
         dfs2();
 //        t=min(dp[1][0],dp[1][1]);
 //        if(dp[1][2]!=-1)//不需要给dp[][2]加负一的特判，只需要保持在不可能时把值设为非常大的值(Maxn)即可
 //            t=min(t,dp[1][2]);//错的，根结点不能为自己和父亲都是服务器，因为没有父亲
         printf("%d\n",min(dp[][],dp[][]));
         scanf("%d",&n);
     }
     return ;
 }