链接：

#include <stdio.h>
int main()
{
    puts("转载请注明出处[vmurder]谢谢");
    puts("网址：blog.csdn.net/vmurder/article/details/45315019");
}

题解：

贪心策略步骤一：

如果有多个儿子，那么显然（这里是真的显然，真的不给证明了）我们肯定要先合并小儿子后合并大儿子。

贪心策略步骤二：

因为所有节点的载重是相同的，所以我们要先合并叶子节点，不能合并就把父亲的权值+1然后叶子就可以去掉啦~（若父亲要被合并上去，那么爷爷就会多出若干被计数为1的儿子）。

证明1：

为什么一定先合并叶子？

因为：

1.如果合并完父亲叶子还能合并，那么无所谓顺序，可以先合并叶子。

2.如果合并完父亲叶子并不能合并啦，那么叶子开始不能合并的情况被考虑到了，没有问题，而能合并的情况则会发现反正对答案的贡献都是1，不妨合并叶子。

3.如果不能合并父亲，那么叶子自然要尽量合并啦。

懒，所以只给一下感性理解。

其它证明：

呃那个+1是有讲究的。可以分别考虑父亲能或者不能被合并到爷爷上的情况~

代码：

#include <queue>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define N 2001000
using namespace std;
struct Eli
{
    int v,next;
}e[N<<2];
int head[N],cnt;
inline void add(int u,int v)
{
    e[++cnt].v=v;
    e[cnt].next=head[u];
    head[u]=cnt;
}
int val[N],n,m;
struct S
{
    int x;
    S(int _=0):x(_){}
    bool operator < (const S &A)const
    {return val[x]>val[A.x];}
};
priority_queue<S>q;
int ans,d[N];
void dfs(int x)
{
    int i,v;
    for(i=head[x];i;i=e[i].next)dfs(e[i].v);
    for(i=head[x];i;i=e[i].next)q.push(S(e[i].v));
    while(!q.empty())
    {
        v=q.top().x,q.pop();
        if(val[x]+val[v]-1<=m)val[x]+=val[v]-1,ans++;
    }
}
int main()
{
    freopen("test.in","r",stdin);
    int i,j,k;
    scanf("%d%d",&n,&m);
    for(i=1;i<=n;i++)scanf("%d",&val[i]);
    for(i=1;i<=n;i++)
    {
        scanf("%d",&k);
        while(k--)
        {
            scanf("%d",&j),j++,val[i]++;
            add(i,j),d[j]=1;
        }
    }
    for(i=1;i<=n;i++)
    {
        if(!d[i])
        {
            dfs(i);
            break;
        }
    }
    printf("%d\n",ans);
    return 0;
}