UVA 1218 完美的服务

https://vjudge.net/problem/UVA-1218

这题注意边界情况。在叶子节点d【u】【2】要注意区别取值，我这里采用的maxn标记。
而且d【u】【1】的取值，在u的孩子中如果有叶子节点那么这个策略是行不通的，也要标记。
接下来就是深度搜索了。我跟网上其他人的做法不太一样。这是一个比较易于理解的做法，写出来发现可以过就没再优化。其实计算d【u】【2】可以再快一点，具体看下面分析。

(u,0)：u是服务器，则每个子结点可以是服务器也可以不是。
d(u,1)：u不是服务器，但u的父亲是服务器，这意味着u的所有子结点都不是服务器。d(u,2)：u和u的父亲都不是服务器。这意味着u恰好有一个儿子是服务器。
状态转移比前面复杂一些，但也不困难。首先可以写出：
d(u,0) = sum{min(d(v,0), d(v,1))} + 1
d(u,1) = sum(d(v,2))
而d(u,2)稍微复杂一点，需要枚举当服务器的子结点编号v，然后把其他所有子结
点v’的d(v’,2)加起来，再和d(v,0)相加。不过如果这样做，每次枚举v都需要O(k)时间（其中k是u的子结点数目），而v本身要枚举k次，因此计算d(u,2)需要花O(k 2 )时间。
刚才的做法有很多重复计算，其实可以利用已经算出的d(u,1)写出一个新的状态转移方程：
d(u,2) = min(d(u,1) – d(v,2) + d(v,0))

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<string.h>
#define maxn 10000+10
#define INF 100000000
vector<int> child[maxn];
int n;
int d[maxn][5];
int vis[maxn];
void initial()
{
    for(int i=0;i<=n;i++)
        child[i].clear();
    memset(d,0,sizeof(d));
}

void dfs(int u)
{
    int size=child[u].size();
    if(!size)//leaf node
    {
        d[u][0]=1;
        d[u][1]=0;
        d[u][2]=maxn;//
        return;
    }

    for(int i=0;i<size;i++)
    {
        int v=child[u][i];
        dfs(v);
        d[u][0]+=min(d[v][0],d[v][1]);      
    }
    d[u][0]++;

    for(int i=0;i<size;i++)
    {
        int v=child[u][i];      
        if(!child[v].size())//leaf node
        {
            d[u][1]=maxn;break;
        }
        d[u][1]+=d[v][2];
    }

    int minn=INF;
    for(int i=0;i<size;i++)
    {
        int v=child[u][i];
        int sum=d[v][0];
        for(int j=0;j<size;j++)
        {
            int v1=child[u][j];
            if(j==i)continue;
            sum+=(d[v1][2]>=maxn?0:d[v1][2]);
        }
        minn=min(minn,sum);
    }
    d[u][2]=minn;

    return;
}

int main()
{
    cin>>n;
    while(1)
    {
        initial();
        int n1,n2,root;
        cin>>n1>>n2;
        vis[n1]=vis[n2]=1;

        root=n1;
        child[n1].push_back(n2);
        for(int i=1;i<=n-2;i++)
        {
            cin>>n1>>n2;

            if(vis[n1])
            {child[n1].push_back(n2);vis[n2]=1;}
            else
            {child[n2].push_back(n1);vis[n1]=1;}
        }

        dfs(root);

        cin>>n;
        int a=min(d[root][0],d[root][2]);
        cout<<a<<endl;      

        if(n==-1)
        break;
        cin>>n;
    }

}