组合数学 + 并查集 - Little W and Contest - HDU 6795

最新推荐文章于 2020-08-07 10:37:59 发布

njuptACMcxk

最新推荐文章于 2020-08-07 10:37:59 发布

阅读量1k

点赞数 3

分类专栏：数学并查集文章标签：算法数学并查集数据结构 ACM

本文链接：https://blog.csdn.net/njuptACMcxk/article/details/107641773

版权

数学同时被 2 个专栏收录

27 篇文章 1 订阅

订阅专栏

并查集

16 篇文章 0 订阅

订阅专栏

组合数学 + 并查集 - Little W and Contest - HDU 6795

2020 Multi-University Training Contest 3

题意：

$给定 n 个点，有两种点，权值分别为 1 和 2 ，$

$初始时， n 个点互不相连。$

$接着会加入 n - 1 条边，保证每次加入的边的两个端点事先是不相连通的。$

$要从中选择 3 个点，满足 3 个点的权值之和不少于 5 ，且 3 个点之间互不相连，计算出不同的选择方案的数量。$

$每加入一条边，都要输出当前连通状态下，不同的选择方案的数量。$

输入：

$首行输入一个正整数 T (1 \leq T \leq 10) ，表示测试数据的组数。$

$每组数据的首行输入一个正整数n(1≤n≤10^5)，表示点的数量，$

$接着输入 n 个数，表示每个点的权值 (1 或 2) 。$

$最后n-1行数据，每行包括两个正整数u_i,v_i，表示在u_i和v_i之间建立一条无向边。$

输出：

$输出 n 行，表示从初始阶段到添加最后一条边的每个阶段，不同方案的总数。$

Sample Input

Sample Output

分析：

$① 、要保证权值之和不少于 5 ，那么有两种组合方式： 2 + 2 + 1 或者 2 + 2 + 2 。$

$② 、顺着题意来计数似乎不太方便 (要考虑缩点、连通块等等问题) 。可以反过来思考。$

$\qquad我们观察样例，发现当边的数量逐渐增多时，方案数一定会递减到0。$

$\qquadⅠ、初始状态的计算：假设权值为1的点的数量为cnt_1，权值为2的点的数量为cnt_2，$

$\qquad\quad\ \ 此时的不同方案的总数:ans=C_{cnt_2}^2×C_{cnt_1}^1+C_{cnt_2}^3$

$\qquadⅡ、我们考虑每次添加一条边后，会有哪一部分的方案会变成不合法的方案，$

$\qquad\quad\ \ 由于每次加边合并都是对两个连通块进行操作，假设现在u和v之间添加一条边，$

$\qquad\quad\ \ 因此，我们将n个点分为3个部分：u所在连通块G_u、v所在的连通块G_v、其他剩余点G_r。$

$\qquad\quad\ \ 对于每个连通块，我们用并查集维护，同时额外维护两个数组p_1和p_2，$

$\qquad\quad\ \ p_1[i]表示以i为根节点的连通块中，权值为1的点的数量，p_2[i]同理。$

$\qquad\quad\ \ 记u所在连通块的根节点为pu，v所在连通块的根节点为pv，$

$\qquad\quad\ \ 那么合并u和v所在的两个连通块后，新增的不合法的方案必是分别从三个部分中各取一个点，$

$\qquad\quad\ \ 有四种可能：$

$\qquad\quad\ \ (1)、从G_u中选择一个权值为2的点，从G_v中选择一个权值为2的点，从G_r中选择一个权值为1的点。$

$\qquad\qquad\quad \ \ \ 方案总数为：p_2[pu]×p_2[pv]×(cnt_1-p_1[pu]-p_1[pv])$

$\qquad\quad\ \ (2)、从G_u中选择一个权值为2的点，从G_v中选择一个权值为2的点，从G_r中选择一个权值为2的点。$

$\qquad\qquad\quad \ \ \ 方案总数为：p_2[pu]×p_2[pv]×(cnt_2-p_2[pu]-p_2[pv])$

$\qquad\quad\ \ (3)、从G_u中选择一个权值为2的点，从G_v中选择一个权值为1的点，从G_r中选择一个权值为2的点。$

$\qquad\qquad\quad \ \ \ 方案总数为：p_2[pu]×p_1[pv]×(cnt_2-p_2[pu]-p_2[pv])$

$\qquad\quad\ \ (4)、从G_u中选择一个权值为1的点，从G_v中选择一个权值为2的点，从G_r中选择一个权值为2的点。$

$\qquad\qquad\quad \ \ \ 方案总数为：p_1[pu]×p_2[pv]×(cnt_2-p_2[pu]-p_2[pv])$

$那么，每次我们用上一阶段的 a n s 减去当前阶段四种情况不合法方案数之和即可。$

$最后合并 u 和 v 所在的连通块。$

注意：

$计算过程中有好几处可能爆 i n t ，比如计算 k 时。$

代码：

#include<cstring>
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cmath>

#define ll long long

using namespace std;

const int N=1e5+10, mod=1e9+7;

int T,n;
int w[N];
int cnt[3];
int p[N];
int p1[N],p2[N];

int Find(int x)
{
    if(p[x]!=x) p[x]=Find(p[x]);
    return p[x];
}

int C_2(int n)
{
    if(n<2) return 0;
    return (ll)(n-1)*n/2%mod;
}

int C_3(int n)
{
    if(n<3) return 0;
    return (ll)(n)*(n-1)*(n-2)/6%mod;
}

int main()
{  
    cin>>T;
    while(T--)
    {
        scanf("%d",&n);
        memset(cnt,0,sizeof cnt);
        for(int i=1;i<=n;i++) 
        {
            scanf("%d",&w[i]);p[i]=i;
            if(w[i]==1) {p1[i]=1, p2[i]=0;cnt[1]++;}
            else {p2[i]=1, p1[i]=0;cnt[2]++;}
        }
        int ans=(C_3(cnt[2])+(ll)C_2(cnt[2])*cnt[1]%mod)%mod;
        printf("%d\n",ans);
        
        int u,v;
        for(int i=0;i<n-1;i++)
        {
            int k=0;
            scanf("%d%d",&u,&v);
            int pu=Find(u), pv=Find(v);

            k=(k+(ll)p1[pu]*p2[pv]*(cnt[2]-p2[pu]-p2[pv]))%mod;
    
            k=(k+(ll)p2[pu]*p1[pv]*(cnt[2]-p2[pu]-p2[pv]))%mod;
            
            k=(k+(ll)p2[pu]*p2[pv]*(cnt[2]-p2[pu]-p2[pv]))%mod;
            
            k=(k+(ll)p2[pu]*p2[pv]*(cnt[1]-p1[pu]-p1[pv]))%mod;
            
            ans=(ans-k+mod)%mod;
            printf("%d\n",ans);
            p[pv]=pu;
            p1[pu]+=p1[pv], p2[pu]+=p2[pv];
            p1[pv]=0, p2[pv]=0;
        }
    }
    
    return 0;
}