HDU 6178 Monkeys

题意：给出一棵 N 个节点树，上面有 K 个猴子，然后竟可能删边，但是每一只猴子必须有直接相邻的猴子与之相邻。求最少剩下几条边。

分析：一条边可以用两只猴子站，这样的一条点对，越多越好，如果是ans个，ans*2>=k，那么只需要 (k+1)/2 条边。

否则，需要  ans + (k-ans*2) 条边。

现在问题就转为求这样的点对有多少，哈哈，有漏洞的DP都AC了，哈哈~~~~。

我发现标程思路也是这样，哈哈，都是bug程序！！！

唯一的解释就是 d[u][1] >= d[u][0] 感性认识

#include <bits/stdc++.h>

using namespace std;

const int maxn = ;

vector<int> g[maxn];

/*------- 开挂 -------*/
namespace fastIO {
    #define BUF_SIZE 100000
    // fread -> read
    bool IOerror = ;

    char nc() {
        static char buf[BUF_SIZE], *pl = buf + BUF_SIZE, *pr = buf + BUF_SIZE;
        if(pl == pr) {
            pl = buf;
            pr = buf + fread(buf, , BUF_SIZE, stdin);
            if(pr == pl) {
                IOerror = ;
                return -;
            }
        }
        return *pl++;
    }

    inline bool blank(char ch) {
        return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
    }

    void read(int &x) {
        char ch;
        while(blank(ch = nc()));
        if(IOerror)
            return;
        for(x = ch - ''; (ch = nc()) >= '' && ch <= ''; x = x *  + ch - '');
    }
    #undef BUF_SIZE
};
using namespace fastIO;
/*------- 完结 -------*/

int d[maxn][]; // 0 匹配
bool vis[maxn];

void dp(int u,int fa) {
    if(vis[u]) return;
    vis[u] = ;

    d[u][] = d[u][] = ;
    int sum = ;
    for(int i=; i < (int)g[u].size(); i++) {
        int v = g[u][i];
        if(v==fa) continue;
        dp(v,u);
        d[u][] += max(d[v][],d[v][]);
        sum+=d[v][];
    }

    for(int i=; i < (int)g[u].size(); i++) {
        int v = g[u][i];
        if(v==fa) continue;
        d[u][] = max(d[u][],sum-d[v][]+d[v][]+);
    }

}

int T;
int N,K;
int main()
{
    //freopen("in.txt","r",stdin);
    read(T);
    while(T--) {
        read(N);
        read(K);

        for(int i=; i <= N; i++)
            g[i].clear();
        memset(vis,,sizeof(vis));

        int u;
        for(int i=; i < N; i++) {
            read(u);
            g[u].push_back(i+);
            g[i+].push_back(u);
        }

        dp(,-);

        int ans = max(d[][],d[][]);
        if(ans*>=K)
            printf("%d\n",(K+)/);
        else
            printf("%d\n",ans+K-(ans*));
    }

    return ;
}