【训练题38：点分治 + 状压】Garden of Eden | HDU5977

最新推荐文章于 2024-10-14 09:08:48 发布

溢流眼泪

最新推荐文章于 2024-10-14 09:08:48 发布

阅读量144

点赞数 1

分类专栏：【各类ACM真题】文章标签：算法分治算法动态规划

本文链接：https://blog.csdn.net/weixin_45775438/article/details/115351915

版权

【各类ACM真题】专栏收录该内容

130 篇文章 22 订阅

订阅专栏

本文介绍了如何使用点分治算法解决一个图论问题：给定一棵树，每个节点有特定颜色，求包含所有颜色的路径数量。通过点分治和状态压缩，实现了O(nlogn×2^10)的时间复杂度解决方案，详细阐述了算法思路、代码实现及复杂度分析。

摘要由CSDN通过智能技术生成

前置

Garden of Eden | HDU5977
点分治的入门题吧，看了百度首页的题解都写的不怎么好看，就自己写一篇 ~~???~~
不懂点分治的小盆友可以戳：【算法讲22：点分治入门】

题意

给定 $n$ 个节点的树，每个节点有一个整数权值 $a_i\in[1,k]$
问你有多少条路径，满足路径上包含了所有颜色的节点？

范围

$1\le n\le 4\times10^5$
$1\le k\le 10$

思路

统计路径条数，想到点分治。问你包含所有颜色，想到状压。于是思路直接就出来了。
算了一下，时间复杂度大概为 $O(n\log n\times 2^{10})$ ，限时 $5000 M s$ 貌似可以直接冲。
某个树找到重心后，我们按一个一个子树去遍历。
其中每个节点的 $d e p [i]$ 表示该节点到根节点的路径上，颜色的和。
那么统计答案，我们就是要去找到之前的桶 $b i g [S]$ ，满足 $S ∣ T = (1 < < k) - 1$
答案就是这样去累加 $\sum big[S_{\ legal}]$
我们这里只需要一个小特判，就不需要去容斥做了。
对于上述的计算，我们算出来的点对是子树间的两两点对。
然而 $(u, v)$ 和 $(v, u)$ 应该算两种，所以我们这些对之间都要乘以2。
我们唯一没有去算的就是单拿根节点的这种方案，明显只有 $k = 1$ 的时候，需要多累加 $n$ 的方案

代码

时间复杂度： $O(n\log n\times 2^{10})$
$T i m e (M s) : 639 / 5000$

/*
 _            __   __          _          _
| |           \ \ / /         | |        (_)
| |__  _   _   \ V /__ _ _ __ | |     ___ _
| '_ \| | | |   \ // _` | '_ \| |    / _ \ |
| |_) | |_| |   | | (_| | | | | |___|  __/ |
|_.__/ \__, |   \_/\__,_|_| |_\_____/\___|_|
        __/ |
       |___/
*/
const int MAX = 5e4 + 50;
int n,k,sum,root;
ll ans;
vector<int>V[MAX],SS[MAX];
int sz[MAX],ff[MAX];
bool vis[MAX];
void find_rt(int x,int f){			/// 点分治求重心
    sz[x] = 1;ff[x] = 0;
    for(auto it : V[x]){
        if(it == f || vis[it])continue;
        find_rt(it,x);
        sz[x] += sz[it];
        ff[x] = max(ff[x],sz[it]);
    }
    ff[x] = max(ff[x],sum - sz[x]);
    if(ff[x] < ff[root])root = x;
}
int sml[MAX],big[1300],tmp[MAX],col[MAX],dep[MAX];
void get_col(int x,int f){			/// 求颜色 dep[i]
    sml[++sml[0]] = dep[x];
    for(auto it : V[x]){
        if(it == f || vis[it])continue;
        dep[it] = dep[x] | (1<<col[it]);
        get_col(it,x);
    }
}
void cal(int x){
    big[0] = 1;
    tmp[0] = 0;
    for(auto it : V[x]){
        if(vis[it])continue;
        sml[0] = 0;
        dep[it] = (1<<col[it]) | (1<<col[x]);		/// 从根节点x出发
        get_col(it,x);
        for(int i = 1;i <= sml[0];++i){
            for(auto j : SS[sml[i]]){
                ans += big[j];						/// 只算合法的答案
            }
        }
        for(int i = 1;i <= sml[0];++i){
            tmp[++tmp[0]] = sml[i];
            big[sml[i]]++;
        }
    }
    for(int i = 1;i <= tmp[0];++i)
        big[tmp[i]]--;
}
void pdc(int x){
    vis[x] = 1;
    cal(x);		/// 只用算从根除法的贡献即可
    for(auto it : V[x]){
        if(vis[it])continue;
        sum = sz[it];
        root = 0;
        find_rt(it,it);
        pdc(root);
    }
}

int main(){

    while(~scanf("%d%d",&n,&k)){
        for(int i = 0;i < (1<<k);++i)SS[i].clear();

        for(int i = 0;i < (1<<k);++i){
            for(int j = 0;j < (1<<k);++j){
                if((i | j) == (1<<k)-1){
                    SS[i].push_back(j);		/// 事先枚举合法的集合
                }
            }
        }
        ans = 0;
        for(int i = 1;i <= n;++i){
            scanf("%d",&col[i]);col[i]--;
            V[i].clear();
            vis[i] = false;
        }
        for(int i = 1;i < n;++i){
            int ta,tb;scanf("%d%d",&ta,&tb);
            V[ta].push_back(tb);
            V[tb].push_back(ta);
        }
        sum = n;
        root= 0;ff[0] = n;
        find_rt(1,1);
        pdc(root);
        ans = ans * 2;					/// 点对答案乘以2
        if(k == 1)ans = ans + n;		/// 简答特判即可回避容斥
        printf("%lld\n",ans);
    }

    return 0;
}