CF Gym102028G Shortest Paths on Random Forests

传送门

这题要求的期望,就是总权值(所有不在同一个连通块点对的贡献+同一连通块点对的贡献)/总方案(森林个数)

先求森林个数,森林是由一堆树组成的,而根据purfer序列,一棵\(n\)个点的有标号的树的个数为\(n^{n-2}\),然后因为点有标号所以可以考虑EGF,设树的EGF为\(F(x)\),那么森林的生成函数为\(e^{F(x)}\)

然后是不在同一个连通块点对的贡献,这等于不在同一个连通块点对个数\(*m^2\),然后不在同一个连通块点对个数又等于总点对个数\(-\)在同一个连通块点对个数.考虑枚举一个连通块的大小,然后这个大小为\(n\)的连通块的贡献为\(n^{n-2}\binom{n}{2}\),然后还要乘上这个连通块出现多少次,那剩下的部分就是一个森林,所以把这个搞成EGF然后卷上之前的森林的生成函数就行了

最后是同一连通块点对的贡献,平方有点难处理,考虑转化一下\[\begin{aligned}\sum_{i=1}^{n}\sum_{j=i+1}^{n}dis(i,j)^2&=\sum_{i=1}^{n}\sum_{j=i+1}^{n}(\sum_{(x,y)\in (i,j)}1)^2\\&=\sum_{i=1}^{n}\sum_{j=i+1}^{n}\sum_{(x1,y1)\in (i,j)}\sum_{(x2,y2)\in (i,j)}1\end{aligned}\]所以也就是枚举两条在路径上的边,然后加起来.我们交换枚举顺序,就先枚举两条边,然后考虑多少条路径同时包含这两条边.如果这两条边是同一条,那么就会把所在连通块分割成两个连通块,否则会分成三个连通块.对于前者,枚举两个连通块大小\(sz_1,sz_2\),然后枚举路径的两个起点,贡献为\(sz_1sz_2\),再枚举这两条边和两个连通块的交点,贡献为\(sz_1sz_2\),所以总贡献为\((sz_1sz_2)^2\).然后三个连通块贡献也类似,也就是\((sz_1sz_2sz_3)^2\).和上面一样,把这个搞成EGF然后卷上之前的森林的生成函数.不过注意三个连通块的情况,我们枚举的两条边是有先后顺序的,所以要\(*2\);然后计算的时候会把\((i,j)\)贡献和\((j,i)\)贡献都算进来,所以这一部分贡献都要\(/2\)

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<vector>
#include<cmath>
#include<ctime>
#include<queue>
#include<map>
#include<set>
#define LL long long
#define db double

using namespace std;
const int N=1e6+10,M=(1<<20)+10,mod=998244353,inv2=499122177;
LL rd()
{
    LL x=0,w=1;char ch=0;
    while(ch<'0'||ch>'9'){if(ch=='-') w=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=(x<<3)+(x<<1)+(ch^48);ch=getchar();}
    return x*w;
}
namespace ct2
{
    int fpow(int a,int b){int an=1;while(b){if(b&1) an=1ll*an*a%mod;a=1ll*a*a%mod,b>>=1;} return an;}
    int ginv(int a){return fpow(a,mod-2);}
    int rdr[M],inv[M],p1[M],p2[M],p3[M],p4[M],p5[M];
    void ntt(int *a,int n,bool op)
    {
        int l=0,x,y;
        while((1<<l)<n) ++l;
        for(int i=0;i<n;++i)
        {
            rdr[i]=(rdr[i>>1]>>1)|((i&1)<<(l-1));
            if(i<rdr[i]) swap(a[i],a[rdr[i]]);
        }
        for(int i=1;i<n;i<<=1)
        {
            int ww=fpow(op?3:332748118,(mod-1)/(i<<1));
            for(int j=0;j<n;j+=i<<1)
                for(int k=0,w=1;k<i;++k,w=1ll*w*ww%mod)
                    x=a[j+k],y=1ll*a[j+k+i]*w%mod,a[j+k]=(x+y)%mod,a[j+k+i]=(x-y+mod)%mod;
        }
        if(!op) for(int i=0,w=ginv(n);i<n;++i) a[i]=1ll*a[i]*w%mod;
    }
    void polyder(int *aa,int *bb,int n)
    {
        for(int i=0;i<n-1;++i) bb[i]=1ll*aa[i+1]*(i+1)%mod;
        bb[n-1]=bb[n]=0;
    }
    void polying(int *aa,int *bb,int n)
    {
        for(int i=1;i<n;++i) bb[i]=1ll*aa[i-1]*inv[i]%mod;
        bb[0]=0;
    }
    void polyinv(int *aa,int *bb,int n)
    {
        if(n==1){bb[0]=ginv(aa[0]);return;}
        polyinv(aa,bb,n>>1);
        for(int i=0;i<n;++i) p1[i]=aa[i],p2[i]=bb[i];
        ntt(p1,n<<1,1),ntt(p2,n<<1,1);
        for(int i=0;i<n<<1;++i) p1[i]=1ll*p1[i]*p2[i]%mod*p2[i]%mod;
        ntt(p1,n<<1,0);
        for(int i=0;i<n;++i) bb[i]=((bb[i]+bb[i])%mod-p1[i]+mod)%mod;
        for(int i=0;i<n<<1;++i) p1[i]=p2[i]=0;
    }
    void polyln(int *aa,int *bb,int n)
    {
        polyder(aa,p3,n),polyinv(aa,p4,n);
        ntt(p3,n<<1,1),ntt(p4,n<<1,1);
        for(int i=0;i<n<<1;++i) p3[i]=1ll*p3[i]*p4[i]%mod;
        ntt(p3,n<<1,0);
        polying(p3,bb,n);
        for(int i=0;i<n<<1;++i) p3[i]=p4[i]=0;
    }
    void polyexp(int *aa,int *bb,int n)
    {
        if(n==1){bb[0]=1;return;}
        polyexp(aa,bb,n>>1);
        polyln(bb,p5,n);
        for(int i=0;i<n;++i) p1[i]=bb[i],p5[i]=(-p5[i]+aa[i]+mod)%mod;
        p5[0]=(p5[0]+1)%mod;
        ntt(p1,n<<1,1),ntt(p5,n<<1,1);
        for(int i=0;i<n<<1;++i) p1[i]=1ll*p1[i]*p5[i]%mod;
        ntt(p1,n<<1,0);
        for(int i=0;i<n;++i) bb[i]=p1[i];
        for(int i=0;i<n<<1;++i) p1[i]=p5[i]=0;
    }
    int fac[N],iac[N],aa[M],f[M],dotf[M],g[M],h[M],h2[M],h3[M],hh[M];
    int C(int n,int m){return m<0||n<m?0:1ll*fac[n]*iac[m]%mod*iac[n-m]%mod;}
    void wk()
    {
        int nn=200010,len=1<<18;
        inv[0]=inv[1]=1;
        for(int i=2;i<=nn;++i) inv[i]=(mod-1ll*(mod/i)*inv[mod%i]%mod)%mod;
        fac[0]=1;
        for(int i=1;i<=nn;++i) fac[i]=1ll*fac[i-1]*i%mod;
        iac[nn]=ginv(fac[nn]);
        for(int i=nn;i;--i) iac[i-1]=1ll*iac[i]*i%mod;
        aa[1]=1;
        for(int i=2;i<=nn;++i) aa[i]=1ll*fpow(i,i-2)*iac[i]%mod;
        polyexp(aa,f,len);
        f[0]=1;
        len<<=1;
        for(int i=0;i<=nn;++i) dotf[i]=f[i];
        ntt(dotf,len,1);
        for(int i=2;i<=nn;++i) g[i]=1ll*C(i,2)*fpow(i,i-2)%mod*iac[i]%mod;
        ntt(g,len,1);
        for(int i=0;i<len;++i) g[i]=1ll*g[i]*dotf[i]%mod;
        ntt(g,len,0);
        h[1]=1;
        for(int i=2;i<=nn;++i) h[i]=1ll*i*i%mod*fpow(i,i-2)%mod*iac[i]%mod;
        ntt(h,len,1);
        for(int i=0;i<len;++i) h2[i]=1ll*h[i]*h[i]%mod;
        ntt(h2,len,0);
        for(int i=1;i<=nn;++i) hh[i]=1ll*h2[i]*inv2%mod;
        for(int i=nn+1;i<len;++i) h2[i]=0;
        ntt(h2,len,1);
        for(int i=0;i<len;++i) h3[i]=1ll*h2[i]*h[i]%mod;
        ntt(h3,len,0);
        for(int i=1;i<=nn;++i) hh[i]=(hh[i]+h3[i])%mod;
        ntt(hh,len,1);
        for(int i=0;i<len;++i) hh[i]=1ll*hh[i]*dotf[i]%mod;
        ntt(hh,len,0);
        for(int i=1;i<=nn;++i)
        {
            f[i]=1ll*f[i]*fac[i]%mod;
            g[i]=1ll*g[i]*fac[i]%mod;
            hh[i]=1ll*hh[i]*fac[i]%mod;
        }
        int T=rd();
        while(T--)
        {
            int n=rd(),m=rd();
            m=1ll*m*m%mod;
            int ans=(1ll*m*(1ll*f[n]*C(n,2)%mod-g[n]+mod)%mod+1ll*hh[n])%mod;
            ans=1ll*ans*ginv(f[n])%mod;
            printf("%d\n",ans);
        }
    }
}

int main()
{
    ct2::wk();
    return 0;
}

原文地址:https://www.cnblogs.com/smyjr/p/11029586.html

时间: 2024-10-12 07:36:42

CF Gym102028G Shortest Paths on Random Forests的相关文章

随机森林——Random Forests

[基础算法] Random Forests 2011 年 8 月 9 日 Random Forest(s),随机森林,又叫Random Trees[2][3],是一种由多棵决策树组合而成的联合预测模型,天然可以作为快速且有效的多类分类模型.如下图所示,RF中的每一棵决策树由众多split和node组成:split通过输入的test取值指引输出的走向(左或右):node为叶节点,决定单棵决策树的最终输出,在分类问题中为类属的概率分布或最大概率类属,在回归问题中为函数取值.整个RT的输出由众多决策树

Bagging(Bootstrap aggregating)、随机森林(random forests)、AdaBoost

引言 在这篇文章中,我会详细地介绍Bagging.随机森林和AdaBoost算法的实现,并比较它们之间的优缺点,并用scikit-learn分别实现了这3种算法来拟合Wine数据集.全篇文章伴随着实例,由浅入深,看过这篇文章以后,相信大家一定对ensemble的这些方法有了很清晰地了解. Bagging bagging能提升机器学习算法的稳定性和准确性,它可以减少模型的方差从而避免overfitting.它通常应用在决策树方法中,其实它可以应用到任何其它机器学习算法中.如果大家对决策树的算法不太

Codeforces 1005 F - Berland and the Shortest Paths

F - Berland and the Shortest Paths 思路: bfs+dfs 首先,bfs找出1到其他点的最短路径大小dis[i] 然后对于2...n中的每个节点u,找到它所能改变的所有前驱(在保证最短路径不变的情况下),即找到v,使得dis[v] + 1 == dis[u],并把u和v所连边保存下来 最后就是dfs递归暴力枚举每个点的前驱,然后输出答案 #include<bits/stdc++.h> using namespace std; #define fi first

随机森林(Random Forests)

简单地看了一些入门的资料. 随机森林似乎和CART有些联系. 随机森林的算法步骤: 1. 利用自助法(Bootstrap)从原始训练集中生成k个自助样本集,每个自助样本集是每棵分类树的全部训练数据.自助法(Bootstrap):从原始的样本容量为N的训练集合中随机抽取N个样本生成新的训练集,抽样的方法是有放回的.这样的抽样方式有可能造成新的训练集中存在重复的样本.2. 每个自助样本集生长为单棵分类树.在树的每个节点从M个特征中随机挑选m个特征(mm),利用这m个特征,按照节点不纯度最小的原则选取

CF 668C Little Artem and Random Variable

题目链接:http://codeforces.com/problemset/problem/641/D 题目大意:一共有两个骰子,每个骰子都有n个面,上面分别是1到n,投到每个面的概率不可知,但是知道投到每个面也就是每个值的最大的概率与最小的概率分别是多少,问两个骰子投到每个面的概率分别是多少 解题思路:数学题 字超级丑请忽略 其中ax是a骰子得到x的概率,bx是b骰子得到x的概率 它们相加等于得到最大x与得到最小x的概率相加,然后用ax表示bx,替换1式中的ax,就能得到一元二次方程,直接解就

【Spark MLlib速成宝典】模型篇06随机森林【Random Forests】(Python版)

目录 随机森林原理 随机森林代码(Spark Python) 随机森林原理 待续... 返回目录 随机森林代码(Spark Python) 代码里数据:https://pan.baidu.com/s/1jHWKG4I 密码:acq1 # -*-coding=utf-8 -*- from pyspark import SparkConf, SparkContext sc = SparkContext('local') from pyspark.mllib.tree import RandomFor

Codeforces 1005F Berland and the Shortest Paths 【最短路树】【性质】

其实是一道裸题,如果没学过最短路树的话会比较难做,要想很久想到关键性质才能做出来. 最短路树顾名思义,就是从一个图中生成出来一棵树,使得每个顶点到root的距离是单源最短路.如果有这样的树的话,那可见这样的树是符合题意的. 怎么生成这样的树呢?关键在于记录前驱father,一个距离root最短路是6的点必定从一个距离root最短路是5的点到达(这两个点之间一定会有一条边).所以我们对于所有顶点 2-n,每个顶点u我们找dis[u] = dis[v]+1的情况,这样的话v就是u的前驱.若v,u之间

Berland and the Shortest Paths CodeForces - 1005F(最短路树)

最短路树就是用bfs走一遍就可以了 d[v] = d[u] + 1 表示v是u的前驱边 然后遍历每个结点 存下它的前驱边 再用dfs遍历每个结点 依次取每个结点的某个前驱边即可 #include <bits/stdc++.h> #define mem(a, b) memset(a, b, sizeof(a)) using namespace std; const int maxn = 1e6+10, INF = 0x7fffffff; int n, m, k, cnt; int head[ma

CF 938G Shortest Path Queries

又到了喜闻乐见的写博客清醒时间了233,今天做的依然是线段树分治 这题算是经典应用了吧,假的动态图(可离线)问题 首先不难想到对于询问的时间进行线段树分治,这样就可以把每一条边出现的时间区间扔进线段树里,考虑如何维护答案 初步的想,图上两点间异或最小值,和最大值类似.先求出一棵生成树,然后把环扔进线性基里,每次查询两点间异或值之后再扔进线性基里求最小值即可 正确性的话,因为这样环一定是有树边+非树边构成的,我们可以在任意一个点走到一个环再绕回来,中间重复走的树边因为走了两次相当于没有影响 然后我