Tree Cutting HDU - 5909 （树形dp + 树分治）

最新推荐文章于 2021-10-29 18:14:10 发布

原创最新推荐文章于 2021-10-29 18:14:10 发布 · 335 阅读

2 ·

CC 4.0 BY-SA版权

树形DP 同时被 2 个专栏收录

21 篇文章

订阅专栏

树分治

5 篇文章

订阅专栏

本文深入探讨了树分治与DP算法结合解决特定问题的方法。通过详细解析树的DFS遍历序列如何帮助我们将树上的动态规划问题转换为线性DP问题，文章提供了清晰的思路和代码实现。特别关注如何利用子树的特性进行状态转移，以及如何通过分治策略高效计算子树的贡献。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

思路：第二道树分治题，但这题首先要先解决dp的递推表达式。

首先先确定一点，同一子树上的dfs序一定是连续的，这也就给了我们一个将树上的dp映射到普通dp上（普通dp我们研究的元素之间通常是连续的）。换句话说，按dfs序的话，我们就可以考虑前i项构成的子树这样的情况，如果不是dfs序，那么前i项可能在不同子树，这与题目要求不符。

设dp[i][j]表示考虑了dfs序的前i项，目前连通块的异或和为j的方案数。

dp[0][0]=1表示没有任何点，异或值为0的方案数为1（什么也不选也是一种）。

考虑转移：第i+1项加进来，那么它的子树也可以加进来，dp[i+1][j^v[dfn[i]]+=dp[i][j]

第i+1项不加入，那么它的子树也不能加，所以需要间隔size[dfn[i]]项，dp[i+size[dfn[i]]][j]+=dp[i][j]

接着考虑分治求各个子树的贡献。

取一个根，将这棵树转化为有根树，并假设根必须要选，那么对于一个点来说，如果它选了，它的父亲就必须选。

求出dfs序，设f[i][j]f[i][j]表示考虑了dfs序的前ii项，目前连通块的异或和为jj的方案数。

如果ii是一个左括号，那么把ff传给儿子，并强制选择儿子；如果ii是个右括号，那么这个子树既可以选又可以不选，累加即可。

如果根必然不选，那么可以去掉这个根，变成若干棵树的子问题，这显然是点分治的形式，取重心作为根即可。

时间复杂度O(nmlogn)。

代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int inf=0x3f3f3f3f;
const int maxn=1e3+38;
const int mod=1e9+7;
int n,v[maxn],m;
int head[maxn*2];
int num;
int M,allnode;
int Focus;
int size[maxn],f[maxn];
bool vis[maxn];
ll dp[maxn][maxn];
int dfn[maxn],tim;
ll ans[maxn];
struct Edge
{    
    int u,v,w,next;
}edge[maxn<<2];
void addEdge(int u,int v,int w)
{    
    edge[num].u=u;    
    edge[num].v=v;    
    edge[num].w=w;    
    edge[num].next=head[u];    
    head[u]=num++;
}
void init()
{
    memset(head,-1,sizeof(head));
    memset(vis,0,sizeof(vis));
    memset(ans,0,sizeof(ans));
    num=0;
}
void getFocus(int u,int pre)
{
    size[u]=1,f[u]=0;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v;
        if(v==pre||vis[v]) continue;
        getFocus(v,u);
        size[u]+=size[v];
        f[u]=max(f[u],size[v]);
    }
    f[u]=max(f[u],allnode-size[u]);
    if(M>f[u])
    {
        M=f[u];
        Focus=u;
    }
}
void dfs(int u,int pre)
{
    size[u]=1;
    dfn[tim++]=u;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v;
        if(v==pre||vis[v]) continue;
        dfs(v,u);
        size[u]+=size[v];
    }
}
void cal()
{
    for(int i=0;i<=tim;i++) //直接用memset会超时
    {
        fill(dp[i],dp[i]+m,0);
    }
    //memset(dp,0,sizeof(dp));
    //memset(dp, 0, m* sizeof *dp);
    dp[0][0]=1;
    for(int i=0;i<tim;i++)
    {
        for(int j=0;j<m;j++)
        {
            dp[i+1][j^v[dfn[i]]]=(dp[i][j]+dp[i+1][j^v[dfn[i]]])%mod;
            dp[i+size[dfn[i]]][j]=(dp[i+size[dfn[i]]][j]+dp[i][j])%mod;
        }
    }
}
void solve(int x)
{
    vis[x]=1;
    tim=0;
    dfs(x,-1);
    cal();
    for(int i=0;i<m;i++)
    {
        ans[i]=(ans[i]+dp[tim][i])%mod;
    }
    ans[0]=(ans[0]+mod-1)%mod;
    for(int i=head[x];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v;
        if(vis[v]) continue;
        allnode=size[v]; M=1e9,Focus=0;
        getFocus(v,x);
        solve(Focus);
    }
}
void print()
{
    for(int i=0;i<m;i++)
    {
        printf("%lld",ans[i]);
        if(i<m-1) printf(" ");
        else printf("\n");
    }
}
int main()
{
    #ifndef ONLINE_JUDGE
        freopen("in.txt","r",stdin);
        freopen("out.txt","w",stdout);
    #endif
    int T;
    cin>>T;
    while(T--)
    {
        init();
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++) scanf("%d",&v[i]);
        for(int i=1,u,v;i<n;i++)
        {
            scanf("%d%d",&u,&v);
            addEdge(u,v,0);
            addEdge(v,u,0);
        }
        M=1e9,Focus=0,allnode=n;
        getFocus(1,-1);
        solve(Focus);
        print();
    }
    return 0;
}