[校内训练2021_03_02]C

题目大意：有一棵n个节点的树，给每个节点分配一个非负整数，使得权值和为m，求出所有方案的 标号最小的带权重心的 标号之和。一个点是带权重心当且仅当以它为根的子树中，所有子树的权值和小于等于m除以2下取整。n=200000,m=5000000，对质数取模。

思考：
首先比较容易发现的一点是 带权重心一定组成一条链。对于m是奇数的情况，带权重心仅有一个，因为从某个带权重心移动必然会导致某一个子树的权值和大于m/2。我们枚举成为带权重心的点，并用容斥的方法求出这个点在多少种方案中出现。令$get(x,y)$表示将x个无区别的球放入y个有区别的盒子并且没有数量限制的方案数，那么$get(x,y)= binom{x+y-1}{x}$。注意到对于u号点不合法的情况，当且仅当某一个子树中的权值和大于等于$frac{m+1}{2}$，于是我们在u号点的方案数，等于$get(m,n)-sum_{vin son}{sum_{i=frac{m+1}{2}}^{m}{get(i,s_{v})*get(m-i,n-s_{v})}}$，其中$s_{v}$是以u为根时，子树v的大小。

我们换个角度思考后面的和式（这一步直接抛弃了前面的式子）：如果我们在子树中先放入$frac{m+1}{2}$个球，那么剩下的球任意放都能被统计到答案里。因此我们可以先确定第$frac{m+1}{2}$个球放在了哪个盒子（相当于节点）里，那么方案数就为$get(m,n)-sum_{vin son}{sum_{i=1}^{s_{v}}{get(frac{m+1}{2}-1,i)*get(frac{m+1}{2}-1,n-i+1)}}$。这个式子把s拿了出来！因此可以算出它的前缀和，在O(m)的时间内完成。

对于m为偶数的情况，我们先将m-1带入奇数算法，这样算出的是没有标号最小限制的方案和。对于一条链（长度大于等于2），它上面的标号不是最小的点会被记重若干次，这个值只和链的两个端点的子树大小有关，因此考虑点分治来解决。每次算贡献时要计算路径上点权最小的点，把当前分治到的联通块的点权从小到大保存下来就不需要用数据结构了。复杂度O(nlogn+m)。

#include<bits/stdc++.h>
#define mod 998244353
using namespace std;
typedef long long int ll;
const int maxn=2E5+5;
const int limit=6E6+5;
int n,m;
ll ans,fac[limit+5],inv[limit+5],preF[maxn];
int size,head[maxn];
int root,sum[maxn],maxp[maxn],fa[maxn],preSum[maxn];
struct edge
{
    int to,next;
}E[maxn*2];
inline void add(int u,int v)
{
    E[++size].to=v;
    E[size].next=head[u];
    head[u]=size;
}
inline ll qpow(ll x,ll y)
{
    ll ans=1,base=x;
    while(y)
    {
        if(y&1)
            ans=ans*base%mod;
        base=base*base%mod;
        y>>=1;
    }
    return ans;
}
inline ll C(int x,int y)
{
    if(x<y||x<0||y<0)
        return 0;
    return fac[x]*inv[y]%mod*inv[x-y]%mod;
}
void dfs(int u,int F)
{
    fa[u]=F;
    preSum[u]=1;
    for(int i=head[u];i;i=E[i].next)
    {
        int v=E[i].to;
        if(v==F)
            continue;
        dfs(v,u);
        preSum[u]+=preSum[v];
        preF[u]=(preF[u]-C(m/2+preSum[v]-1,m/2))%mod;
    }
    preF[u]=(preF[u]-C(m/2+n-preSum[u]-1,m/2))%mod;
}
inline void init()
{
    fac[0]=1;
    for(int i=1;i<=limit;++i)
        fac[i]=fac[i-1]*i%mod;
    inv[limit]=qpow(fac[limit],mod-2);
    for(int i=limit-1;i>=0;--i)
        inv[i]=inv[i+1]*(i+1)%mod;
}
inline ll getF(int u,int v)
{
    if(v==fa[u])
        return (preF[u]+C(m/2+n-preSum[u]-1,m/2)+C(m/2+preSum[u]-1,m/2))%mod;
    return (preF[u]+C(m/2+preSum[v]-1,m/2)+C(m/2+n-preSum[v]-1,m/2))%mod;
}
namespace work1
{
    ll f[maxn];
    inline ll get(int x,int y)
    {
        return C(x+y-1,x);
    }
    void init(int u,int F)
    {
        sum[u]=1;
        for(int i=head[u];i;i=E[i].next)
        {
            int v=E[i].to;
            if(v==F)
                continue;
            init(v,u);
            sum[u]+=sum[v];
        }
    }
    void dfs(int u,int F,int tot)
    {
        vector<int>wait;
        int g=0;
        for(int i=head[u];i;i=E[i].next)
        {
            int v=E[i].to;
            if(v==F)
                continue;
            g+=sum[v];
            wait.push_back(sum[v]);
        }
        wait.push_back(tot);
        ll s=get(m,n);
        for(int i=0;i<wait.size();++i)
            s-=f[wait[i]];
        s%=mod;
        ans=(ans+s*u)%mod;
        for(int i=head[u];i;i=E[i].next)
        {
            int v=E[i].to;
            if(v==F)
                continue;
            dfs(v,u,tot+g-sum[v]+1);
        }
    }
    inline void main(int l)
    {
        for(int i=1;i<=n;++i)
            f[i]=(f[i-1]+get(l-1,i)*get(m-l,n-i+1))%mod;// !!!!!!!
        init(1,0);
        dfs(1,0,0);
    }
}
namespace work2
{
    bool vis[maxn];
    int TI,visT[maxn],fa[maxn];
    ll f[maxn];
    void get(int u,int F)
    {
        fa[u]=F;
        sum[u]=1;
        for(int i=head[u];i;i=E[i].next)
        {
            int v=E[i].to;
            if(vis[v]||v==F)
                continue;
            get(v,u);
            sum[u]+=sum[v];
        }
    }
    void getRoot(int u,int F,int tot)
    {
        maxp[u]=0;
        for(int i=head[u];i;i=E[i].next)
        {
            int v=E[i].to;
            if(v==F||vis[v])
                continue;
            getRoot(v,u,tot);
            maxp[u]=max(maxp[u],sum[v]);
        }
        maxp[u]=max(maxp[u],tot-sum[u]);
        if(maxp[root]>maxp[u])
            root=u;
    }
    int totC,bel[maxn];
    ll sumF[maxn];
    void getFF(int u,int F,int c)
    {
        bel[u]=c;
        f[u]=getF(u,F);
        for(int i=head[u];i;i=E[i].next)
        {
            int v=E[i].to;
            if(v==F||vis[v])
                continue;
            getFF(v,u,c);
        }
        sumF[c]=(sumF[c]+f[u])%mod;
    }
    void cut(int u,int F,ll base,ll now)
    {
        ans=(ans-base*f[u]%mod*now)%mod;
        for(int i=head[u];i;i=E[i].next)
        {
            int v=E[i].to;
            if(vis[v]||v==F)
                continue;
            cut(v,u,base,now+v);
        }
    }
    ll fill(int u,int F,int c)
    {
        if(visT[u]==c)
            return 0;
        visT[u]=c;
        ll s=f[u];
        for(int i=head[u];i;i=E[i].next)
        {
            int v=E[i].to;
            if(v==F||vis[v]||visT[v]==c)
                continue;
            s+=fill(v,u,c);
        }
        sumF[bel[u]]=(sumF[bel[u]]-f[u])%mod;
        return s%mod;
    }
    vector<int>wait[maxn];
    int what[maxn];
    void solve(int u,vector<int>D)
    {
        vis[u]=1;
        ++TI;
        ll totF=0;
        sum[u]=0;
        for(int i=head[u];i;i=E[i].next)
        {
            int v=E[i].to;
            if(vis[v])
                continue;
            ++totC;
            get(v,u);
            getFF(v,u,totC);
            totF=(totF+sumF[totC])%mod;
            what[totC]=v;
            sum[u]+=sum[v];
        }
        ll s=0;
        for(int i=head[u];i;i=E[i].next)
        {
            int v=E[i].to;
            if(vis[v])
                continue;
            ll now=getF(u,v);
            cut(v,u,(totF-sumF[bel[v]]+now)%mod,v);
            ans=(ans-s*sumF[bel[v]]%mod*u)%mod;
            ans=(ans-now*u%mod*sumF[bel[v]])%mod;
            s=(s+sumF[bel[v]])%mod;
        }
        int now=n+1;
        for(int i=0;i<D.size();++i)
        {
            int pos=D[i];
            if(pos==u)
            {
                now=u;
                continue;
            }
            totF-=sumF[bel[pos]];
            ll x=fill(pos,fa[pos],TI);
            ans=(ans+totF*x%mod*min(pos,now))%mod;
            
            ans=(ans+x*min(pos,now)%mod*getF(u,what[bel[pos]]))%mod;
            totF+=sumF[bel[pos]];
            totF%=mod;
            wait[bel[pos]].push_back(pos);
        }
        for(int i=head[u];i;i=E[i].next)
        {
            int v=E[i].to;
            if(vis[v])
                continue;
            root=0;
            get(v,u);
            getRoot(v,u,sum[v]);
            solve(root,wait[bel[v]]);
        }
    }
    inline void main()
    {
        dfs(1,0);
        maxp[0]=n+1;
        get(1,0);
        getRoot(1,0,n);
        vector<int>D;
        for(int i=1;i<=n;++i)
            D.push_back(i);
        solve(root,D);
    }
}
inline void solve()
{
    work1::main(m/2+1);
    if(m%2==0)
        work2::main();
    ans=(ans%mod+mod)%mod;
    cout<<ans<<endl;
}
int main()
{
    ios::sync_with_stdio(false);
    cin>>n>>m;
    init();
    for(int i=2;i<=n;++i)
    {
        int x,y;
        cin>>x>>y;
        add(x,y);
        add(y,x);
    }
    solve();
    return 0;
}