2017 多校训练第十场 HDU 6178 Monkeys 最小点覆盖+树形DP

题目大意：


给你N个点的一棵树，现在有K只猴子，猴子们不会落单，也就是说，在同一个联通块中，至少有两只猴子。
现在我们希望砍尽可能多的边，使得这K只猴子分部在若干个联通块中，使得满足上述条件。
输出剩下的最少的边数。


思路：


这题O（n）做竟然卡读入优化。。。。。。。。。。。。。。。。。。。。。。


①很显然，如果我们最终的答案是一个包含K个点的整个联通块的话，显然答案就是K-1.如果我们是两个共包含K个点的联通块的话，显然答案会对应减少。
所以我们希望分部的情况是尽可能多的联通块，那么理应我们希望将结果分成若干个两两相连的小联通块。


②我们希望构成尽可能多的这样两两相连的小联通块（只用一条边去连接）的话，很显然是需要跑最大二分匹配数。我们知道最小点覆盖==最大二分匹配数，而直接建图跑二分图匈牙利匹配的话，时间复杂度很爆炸，我们知道树形dp可以O（n）求树上的最小点覆盖问题，所以我们直接跑树形Dp即可。


③如果我们最小点覆盖数为ans个，那么分情况讨论即可：
如果k<=ans*2，那么结果就是k/2
如果k>ans*2，那么结果就是k-ans*2+ans（多出来的点直接往上加即可）
如果k是奇数，那么答案再加1.

Ac代码：顺便也是超神输入输出挂的一个升级

#include <bits/stdc++.h>
using namespace std;
// #define test TEST
typedef long long ll;
//超神输入输出挂
namespace IO {
	#define BUF_SIZE 100000
	#define OUT_SIZE 100000
	//fread -> read
	bool IOerror = 0;
	inline char nc() {
		static char buf[BUF_SIZE], *p1 = buf + BUF_SIZE, *pend = buf + BUF_SIZE;
		if (p1 == pend) {
			p1 = buf;
			pend = buf + fread(buf, 1, BUF_SIZE, stdin);
			if (pend == p1) {
				IOerror = 1;
				return -1;
			}
		}
		return *p1++;
	}
	inline bool blank(char ch) {
		return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
	}
	inline bool read(int &x) {
		char ch;
		while (blank(ch = nc()));
		if (IOerror)
			return false;
		for (x = ch - '0'; (ch = nc()) >= '0' && ch <= '9'; x = x * 10 + ch - '0');
		return true;
	}
	inline void read(double &x){
		bool sign=0; char ch=nc(); x=0;
		for(;blank(ch);ch=nc());
		if(IOerror)return;
		if(ch=='-')sign=1,ch=nc();
		for (;ch>='0'&&ch<='9';ch=nc())x=x*10+ch-'0';
		if(ch=='.'){
			double tmp=1; ch=nc();
			for (;ch>='0'&&ch<='9';ch=nc())tmp/=10.0,x+=tmp*(ch-'0');
		} 
		if(sign)x=-x;
	}
	inline void read(char *s){
		char ch=nc();
		for (;blank(ch);ch=nc());
		if (IOerror)return;
		for (;!blank(ch)&&!IOerror;ch=nc())*s++=ch;
		*s=0;
	}
	inline void read(char &c){
		for (c=nc();blank(c);c=nc());
		if (IOerror){c=-1;return;}
	}
	//fwrite->write
	struct Ostream_fwrite{
		char *buf,*p1,*pend;
		Ostream_fwrite(){buf=new char[BUF_SIZE];p1=buf;pend=buf+BUF_SIZE;}
		void out(char ch){
			if (p1==pend){
			fwrite(buf,1,BUF_SIZE,stdout);p1=buf;
		}
		*p1++=ch;
	}
	void print(int x){
		static char s[15],*s1;s1=s;
		if (!x)*s1++='0';if (x<0)out('-'),x=-x;
		while(x)*s1++=x%10+'0',x/=10;
		while(s1--!=s)out(*s1);
	}
	void println(int x){
		static char s[15],*s1;s1=s;
		if (!x)*s1++='0';if (x<0)out('-'),x=-x;
		while(x)*s1++=x%10+'0',x/=10;
		while(s1--!=s)out(*s1); out('\n');
	}
	void print(ll x){
		static char s[25],*s1;s1=s;
		if (!x)*s1++='0';if (x<0)out('-'),x=-x;
		while(x)*s1++=x%10+'0',x/=10;
		while(s1--!=s)out(*s1);
	}
	void println(ll x){
		static char s[25],*s1;s1=s;
		if (!x)*s1++='0';if (x<0)out('-'),x=-x;
		while(x)*s1++=x%10+'0',x/=10;
		while(s1--!=s)out(*s1); out('\n');
	}
	// void print(double x,int y){
	// 	static ll mul[]={1,10,100,1000,10000,100000,1000000,10000000,100000000,
	// 	1000000000,10000000000LL,100000000000LL,1000000000000LL,10000000000000LL,
	// 	100000000000000LL,1000000000000000LL,10000000000000000LL,100000000000000000LL};
	// 	if (x<-1e-12)out('-'),x=-x;x*=mul[y];
	// 	ll x1=(ll)floor(x); if (x-floor(x)>=0.5)++x1;
	// 	ll x2=x1/mul[y],x3=x1-x2*mul[y]; print(x2);
	// 	if (y>0){out('.'); for (size_t i=1;i<y&&x3*mul[i]<mul[y];out('0'),++i); print(x3);}
	// }
	// void println(double x,int y){print(x,y);out('\n');}
	void print(char *s){while (*s)out(*s++);}
	void println(char *s){while (*s)out(*s++);out('\n');}
	void flush(){if (p1!=buf){fwrite(buf,1,p1-buf,stdout);p1=buf;}}
	~Ostream_fwrite(){flush();}
	}Ostream;
	#undef OUT_SIZE
	#undef BUF_SIZE
};
const int maxn=100005;
bool vis[maxn];
int p[maxn],son[maxn];

int main(int argc, char const *argv[])
{
	#ifdef test
	freopen("test.txt","r",stdin);
	#endif 
	int T;
	IO::read(T);
	while(T--){
		int n,k,u;
		IO::read(n);
		IO::read(k);
        for(int i=1;i<=n;i++){
            son[i]=0;
            vis[i]=false;
        }
		for(int i=2;i<=n;i++){
			IO::read(u);
            p[i]=u;
            son[u]++;
		}
        int res=0;
        for(int i=n;i>1;i--){
            if(son[i]==0&&!vis[i]&&!vis[p[i]]){
                vis[i]=1;
                vis[p[i]]=1;
                res++;
                son[p[i]]--;
                son[p[p[i]]]--;
            }
        }
        if(k<=2*res){
            // printf("%d\n",(k-1)/2+1);
            IO::Ostream.println((k-1)/2+1);
        }else{
            // printf("%d\n",k-res);
            IO::Ostream.println(k-res);
        }
	}
	return 0;
}