2022河南省赛 J.Mex Tree（树上MEX） Codeforces Global Round 23 D（树形DP，贪心）

J.Mex Tree

题意：给定一棵树有N个节点N-1条边，每个节点都有权值，我们现在想要知道mex为0,1,2…n-1的最大连通图是多少（大，指点多）

思路：我们假如正向去想的话这题可以说是非常复杂了，你只能暴力去统计，复杂度直接起飞。

但是我们不妨换个角度思考。

他的要求出树上的MEX为k的时候最大的点集，那么假设我们按照节点编号就是点权的角度来考虑，当MEX为k时，我们需要选择0-k-1号节点，所以对于以第k号节点为根的子树，他的子树内部不能存在有比他的编号还小的点否则就会出现，想要选择编号为0-k-1的节点就必须选择k号节点，从而造成mex必然不是k。所以我们只需要考虑子树内编号最小的编号节点是谁就行。

既然这样做简单，我们如何把给定的数变成这样呢。
显然，题目中给了很强的提示：权值是一个0到n-1的排列。
所以按照权值建树即可。

特别注意，对于0的情况，由于是根节点而且值特殊（任何权值都比他大），所以他的最佳答案就是最大的一棵子树。

#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N = 1e5+100;
struct node
{
    int nex,to;
}edge[N<<1];
int n,siz[N],tot,head[N],a[N],minn[N],ans[N];
void add(int from,int to)
{
    edge[++tot].to=to;
    edge[tot].nex=head[from];
    head[from]=tot;
}
void DFS(int now,int fa)
{
    siz[now]=1;
    minn[now]=1e9+1;
    for(int i=head[now];i!=-1;i=edge[i].nex)
    {
        int to=edge[i].to;
        if(to==fa)
            continue;
        DFS(to,now);
        siz[now]+=siz[to];
        minn[now]=min(minn[now],minn[to]);
    }
    if(minn[now]>now)
    {
        ans[now]=n-siz[now];
    }
    minn[now]=min(minn[now],now);
}
signed main()
{
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    cin>>n;
    for(int i=0;i<=n;i++)
        head[i]=-1;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
    }
    for(int i=2,temp;i<=n;i++)
    {
        cin>>temp;
        add(a[temp],a[i]);
        add(a[i],a[temp]);
    }
    DFS(0,-1);
    for(int i=head[0];i!=-1;i=edge[i].nex)
    {
        ans[0]=max(ans[0],siz[edge[i].to]);
    }
    for(int i=0;i<n;i++)
        cout<<ans[i]<<" ";
    cout<<n<<endl;
    return 0;
}

D. Paths on the Tree

题意：我们可以选从根而下的k个路径，但是有个要求，路径所涉及的所有节点的儿子节点被选择次数的差值不能大于1，整个树的贡献是：所有被选节点的权值和被选次数的乘积之和

思路：一个自然的思路是树形DP结合贪心：选择次数k作为权值往下传，传到最低端再由低端返回的贡献来断定我们应该如何分配这些权值。

那么怎么实现呢。

我们可以先传选择的次数，贪心的策略是：让所有节点的选择次数尽可能一致，但是毕竟选择次数不可能总是被儿子节点数整除的，所以会产生余数r，r就要优先分配给贡献最大的前r个节点。

好的思路已经很明晰了，我们来设计DP状态
假设每个节点能分配到的选择次数最少是x次，那么最多显然就是x+1次
dp[i][1] 代表第i号节点被选择了x+1次的贡献，dp[i][0]代表第i号节点被选择x次的贡献。

具体见代码。

#include <bits/stdc++.h>

using namespace std;
#define int long long
const int N = 2e5+100;
struct node
{
    int nex,to;
}edge[N<<1];
int head[N],tot;
int s[N],n,k;
void add(int from,int to)
{
    edge[++tot].nex=head[from];
    head[from]=tot;
    edge[tot].to=to;
}
int dp[N][2];
bool cmp(const pair<int,int> &a,const pair<int,int> &b)
{
    return a.first>b.first;
}
void DFS(int now,int fa,int v)
{
    dp[now][0]=v*s[now];
    dp[now][1]=(v+1)*s[now];
    vector<int> son;
    vector<pair<int,int>> dis;
    for(int i=head[now];i;i=edge[i].nex)
    {
        int to=edge[i].to;
        if(to==fa)
            continue;
        son.push_back(i);
    }
    if(son.size()==0)
        return ;
    int vv=v/son.size();
    int r=v%son.size();
    for(int i=head[now];i;i=edge[i].nex)
    {
        int to=edge[i].to;
        if(to==fa)
            continue;
        DFS(to,now,vv);
    }
    for(int i=head[now];i;i=edge[i].nex)
    {
        int to=edge[i].to;
        if(to==fa)
            continue;
        dis.push_back(make_pair(dp[to][1]-dp[to][0],to));
    }
    sort(dis.begin(),dis.end(),cmp);
    for(int i=0;i<dis.size();i++)
    {
        if(i<r)
            dp[now][0]+=dp[dis[i].second][1];
        else
            dp[now][0]+=dp[dis[i].second][0];
        if(i<=r)
            dp[now][1]+=dp[dis[i].second][1];
        else
            dp[now][1]+=dp[dis[i].second][0];
    }
}
void init()
{
    for(int i=0;i<=tot;i++)
        edge[i].nex=edge[i].to=0;
    for(int i=0;i<=n;i++)
        head[i]=0;
    for(int i=0;i<=n;i++)
        dp[i][0]=dp[i][1]=0;
    tot=0;
}
signed main()
{
    int t;
    cin.tie(0);cout.tie(0);ios::sync_with_stdio(0);
    for(cin>>t;t;t--)
    {
        cin>>n>>k;
        for(int i=2,a;i<=n;i++)
        {
            cin>>a;
            add(a,i);
            add(i,a);
        }
        for(int i=1;i<=n;i++)
            cin>>s[i];
        DFS(1,0,k);
        cout<<dp[1][0]<<endl;
        init();
    }
    return 0;
}