luoguP5644 [PKUWC2018]猎人杀 概率期望+生成函数+NTT

好神仙的概率题啊

我感觉第一步转化好难想,但是想出来第一步的转化方法的话后面用生成函数算背包就很简单了.

code:

#include <cmath>
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <string>
#define ll long long
#define ull unsigned long long
using namespace std;
namespace IO
{
    char buf[100000],*p1,*p2;
    #define nc() (p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++)
    int rd()
    {
        int x=0; char s=nc();
        while(s<‘0‘) s=nc();
        while(s>=‘0‘) x=(((x<<2)+x)<<1)+s-‘0‘,s=nc();
        return x;
    }
    void print(int x) {if(x>=10) print(x/10);putchar(x%10+‘0‘);}
    void setIO(string s)
    {
        string in=s+".in";
        string out=s+".out";
        freopen(in.c_str(),"r",stdin);
        // freopen(out.c_str(),"w",stdout);
    }
};
const int G=3;
const int N=4000005;
const int mod=998244353;
int A[N],B[N],w[2][N],mem[N*100],*ptr=mem,tmpa[N],tmpb[N],aa[N],bb[N];
inline int qpow(int x,int y)
{
    int tmp=1;
    for(;y;y>>=1,x=(ll)x*x%mod)     if(y&1) tmp=(ll)tmp*x%mod;
    return tmp;
}
inline int INV(int a) { return qpow(a,mod-2); }
inline void ntt_init(int len)
{
    int i,j,k,mid,x,y;
    w[1][0]=w[0][0]=1,x=qpow(3,(mod-1)/len),y=qpow(x,mod-2);
    for (i=1;i<len;++i) w[0][i]=(ll)w[0][i-1]*x%mod,w[1][i]=(ll)w[1][i-1]*y%mod;
}
void NTT(int *a,int len,int flag)
{
    int i,j,k,mid,x,y;
    for(i=k=0;i<len;++i)
    {
        if(i>k)    swap(a[i],a[k]);
        for(j=len>>1;(k^=j)<j;j>>=1);
    }
    for(mid=1;mid<len;mid<<=1)
        for(i=0;i<len;i+=mid<<1)
            for(j=0;j<mid;++j)
            {
                x=a[i+j], y=(ll)w[flag==-1][len/(mid<<1)*j]*a[i+j+mid]%mod;
                a[i+j]=(x+y)%mod;
                a[i+j+mid]=(x-y+mod)%mod;
            }
    if(flag==-1)
    {
        int rev=INV(len);
        for(i=0;i<len;++i)    a[i]=(ll)a[i]*rev%mod;
    }
}
inline void getinv(int *a,int *b,int len,int la)
{
    if(len==1) { b[0]=INV(a[0]);   return; }
    getinv(a,b,len>>1,la);
    int l=len<<1,i;
    memset(A,0,l*sizeof(A[0]));
    memset(B,0,l*sizeof(A[0]));
    memcpy(A,a,min(la,len)*sizeof(a[0]));
    memcpy(B,b,len*sizeof(b[0]));
    ntt_init(l);
    NTT(A,l,1),NTT(B,l,1);
    for(i=0;i<l;++i)  A[i]=((ll)2-(ll)A[i]*B[i]%mod+mod)*B[i]%mod;
    NTT(A,l,-1);
    memcpy(b,A,len<<2);
}
void get_dao(int *a,int *b,int len)
{
    for(int i=1;i<len;++i) b[i-1]=(ll)i*a[i]%mod;
    b[len-1]=0;
}
void get_jifen(int *a,int *b,int len)
{
    for(int i=1;i<len;++i) b[i]=(ll)INV(i)*a[i-1]%mod;
    b[0]=0;
}
void get_ln(int *a,int *b,int len,int la)
{
    int l=len<<1,i;
    memset(tmpa,0,l<<2);
    memset(tmpb,0,l<<2);
    get_dao(a,tmpa,min(len,la));
    getinv(a,tmpb,len,la);
    ntt_init(l);
    NTT(tmpa,l,1),NTT(tmpb,l,1);
    for(i=0;i<l;++i) tmpa[i]=(ll)tmpa[i]*tmpb[i]%mod;
    NTT(tmpa,l,-1);
    get_jifen(tmpa,b,len);
}
void get_exp(int *a,int *b,int len,int la)
{
    if(len==1) { b[0]=1; return; }
    int l=len<<1,i;
    get_exp(a,b,len>>1,la);
    for(i=0;i<l;++i)  aa[i]=bb[i]=0;
    for(i=0;i<(len>>1);++i) aa[i]=b[i];
    get_ln(b,bb,len,len>>1);
    for(i=0;i<len;++i) bb[i]=(ll)(mod-bb[i]+(i>la?0:a[i]))%mod;
    bb[0]=(bb[0]+1)%mod;
    ntt_init(l);
    NTT(aa,l,1),NTT(bb,l,1);
    for(i=0;i<l;++i) aa[i]=(ll)aa[i]*bb[i]%mod;
    NTT(aa,l,-1);
    for(i=0;i<len;++i)  b[i]=aa[i];
}
struct poly
{
    int len,*a;
    poly(){}
    poly(int l) {len=l,a=ptr,ptr+=l; }
    inline void rev() { reverse(a,a+len); }
    inline void fix(int l) {len=l,a=ptr,ptr+=l;}
    inline void get_mod(int l) { for(int i=l;i<len;++i) a[i]=0;  len=l;  }
    inline poly dao()
    {
        poly re(len-1);
        for(int i=1;i<len;++i)  re.a[i-1]=(ll)i*a[i]%mod;
        return re;
    }
    inline poly jifen()
    {
        poly c;
        c.fix(len+1);
        c.a[0]=0;
        for(int i=1;i<=len;++i) c.a[i]=(ll)a[i-1]*INV(i)%mod;
        return c;
    }
    inline poly Inv(int l)
    {
        int lim=1;
        while(lim<=l) lim<<=1;
        poly b(lim);
        getinv(a,b.a,lim,len);
        return b;
    }
    inline poly ln(int l)
    {
        int lim=1;
        while(lim<=l) lim<<=1;
        poly b(lim);
        get_ln(a,b.a,lim,len);
        return b;
    }
    inline poly exp(int l)
    {
        int lim=1;
        while(lim<=l) lim<<=1;
        poly b(lim);
        get_exp(a,b.a,lim,len);
        b.get_mod(l);
        return b;
    }
    inline poly operator*(const poly &b) const
    {
        poly c(len+b.len-1);
        if(c.len<=500)
        {
            for(int i=0;i<len;++i)
                if(a[i])   for(int j=0;j<b.len;++j)  c.a[i+j]=(c.a[i+j]+(ll)(a[i])*b.a[j])%mod;
            return c;
        }
        int n=1;
        while(n<(len+b.len)) n<<=1;
        memset(A,0,n<<2);
        memset(B,0,n<<2);
        memcpy(A,a,len<<2);
        memcpy(B,b.a,b.len<<2);
        ntt_init(n);
        NTT(A,n,1), NTT(B,n,1);
        for(int i=0;i<n;++i) A[i]=(ll)A[i]*B[i]%mod;
        NTT(A,n,-1);
        memcpy(c.a,A,c.len<<2);
        return c;
    }
    poly operator+(const poly &b) const
    {
        poly c(max(len,b.len));
        for(int i=0;i<c.len;++i)  c.a[i]=((i<len?a[i]:0)+(i<b.len?b.a[i]:0))%mod;
        return c;
    }
    poly operator-(const poly &b) const
    {
        poly c(len);
        for(int i=0;i<len;++i)
        {
            if(i>=b.len)   c.a[i]=a[i];
            else c.a[i]=(a[i]-b.a[i]+mod)%mod;
        }
        return c;
    }
    poly operator/(poly u)
    {
        int n=len,m=u.len,l=1;
        while(l<(n-m+1)) l<<=1;
        rev(),u.rev();
        poly v=u.Inv(l);
        v.get_mod(n-m+1);
        poly re=(*this)*v;
        rev(),u.rev();
        re.get_mod(n-m+1);
        re.rev();
        return re;
    }
    poly operator%(poly u)
    {
        poly re=(*this)-u*(*this/u);
        re.get_mod(u.len-1);
        return re;
    }
}po;
int wi[N],n;
poly solve(int l,int r)
{
    if(l==r)
    {
        poly c;
        c.fix(wi[l]+1);
        c.a[0]=1;
        c.a[wi[l]]=mod-1;
        return c;
    }
    int mid=(l+r)>>1;
    return solve(l,mid)*solve(mid+1,r);
}
int main()
{
    int i,j,Sum=0;
    // IO::setIO("input");
    scanf("%d",&n);
    for(i=1;i<=n;++i) scanf("%d",&wi[i]),Sum+=wi[i];
    poly re=solve(2,n);
    int ans=0;
    for(i=0;i<=Sum-wi[1];++i)
    {
        (ans+=(ll)wi[1]*INV(i+wi[1])%mod*re.a[i]%mod)%=mod;
    }
    printf("%d\n",ans);
    return 0;
}

  

原文地址:https://www.cnblogs.com/guangheli/p/12235871.html

时间: 2024-11-03 06:35:49

luoguP5644 [PKUWC2018]猎人杀 概率期望+生成函数+NTT的相关文章

「PKUWC2018」猎人杀(分治NTT+概率期望)

Description 猎人杀是一款风靡一时的游戏"狼人杀"的民间版本,他的规则是这样的: 一开始有 \(n\) 个猎人,第 \(i\) 个猎人有仇恨度 \(w_i\) ,每个猎人只有一个固定的技能:死亡后必须开一枪,且被射中的人也会死亡. 然而向谁开枪也是有讲究的,假设当前还活着的猎人有 \([i_1,i_2,...,i_m]\),那么有 \(\frac{w_{i_k}}{\sum_{j=1}^nw_{i_j}}\) 的概率是向猎人 \(k\) 开枪. 一开始第一枪由你打响,目标的选

Loj #2541「PKUWC2018」猎人杀

Loj #2541. 「PKUWC2018」猎人杀 题目链接 好巧妙的题! 游戏过程中,概率的分母一直在变化,所以就非常的不可做. 所以我们将问题转化一下:我们可以重复选择相同的猎人,只不过在一个猎人被选择了过后我们就给他打上标记,再次选择他的时候就无效.这样与原问题是等价的. 证明: 设\(sum=\sum_iw_i,kill=\sum_{i被杀死了}w_i\). 攻击到未被杀死的猎人\(i\)的概率为\(P\). 则根据题意\(P=\frac{w_i}{sum-kill}\). 问题转化后:

hdu 4586 (概率+期望)

http://acm.hdu.edu.cn/showproblem.php?pid=4586 大致题意:有一个骰子有n个面,掷到每一个面的概率是相等的,每一个面上都有相应的钱数.其中当你掷到m个面之一时,你有多掷一次的机会.问最后所得钱数的期望. 思路:设投掷第一次的期望是p,那么第二次的期望是m/n*p,第三次的期望是 (m/n)^2*p......第N次的期望是(m/n)^(N-1)*p. 那么这些期望之和便是答案.之前也是想到这,但不知道如何处理无限的情况.当时脑卡了,这不是赤裸裸的等比数

OI队内测试一【数论概率期望】

版权声明:未经本人允许,擅自转载,一旦发现将严肃处理,情节严重者,将追究法律责任! 测试分数:110 本应分数:160 改完分数:200 T1: 题解:推出了一个初始式子但是n的4分之3次方 忘了合并[实际上是没发现]本来应有60分的,但是忘记开long long 只有30分 因为一些公式不好写出来就直接截图题解吧! T2: 题解:很简单的概率期望,算出每个点被选的概率,然后在上树状数组或者线段树求逆序队,但是我只有80分,为什么解法不行?NO NO 你还是太年轻我只是线段树数据范围开小了!![

uvalive 7331 Hovering Hornet 半平面交+概率期望

题意:一个骰子在一个人正方形内,蜜蜂在任意一个位置可以出现,问看到点数的期望. 思路:半平面交+概率期望 1 #include<cstdio> 2 #include<cstring> 3 #include<algorithm> 4 #include<iostream> 5 #include<cstdlib> 6 #include<string> 7 #include<cmath> 8 #include<vector&

【BZOJ-1419】Red is good 概率期望DP

1419: Red is good Time Limit: 10 Sec  Memory Limit: 64 MBSubmit: 660  Solved: 257[Submit][Status][Discuss] Description 桌面上有R张红牌和B张黑牌,随机打乱顺序后放在桌面上,开始一张一张地翻牌,翻到红牌得到1美元,黑牌则付出1美元.可以随时停止翻牌,在最优策略下平均能得到多少钱. Input 一行输入两个数R,B,其值在0到5000之间 Output 在最优策略下平均能得到多少钱

Lightoj 1027 概率期望

Problem: 概率期望 Analyse: 非常经典的带有递归实现,的方程期望式子. E为期望,z为正数个数,zp为正数平均值,f为负数个数,fp为负数平均值. z?zpn+f?fp+En=E /**********************jibancanyang************************** *Author* :jibancanyang *Created Time* : 五 5/ 6 23:58:46 2016 *File Name* : .cpp **Code**:

hdu4405--Aeroplane chess+概率期望dp

首先推荐一篇很好的如何概率期望问题的入门文章:点击打开链接 昨天比赛的时候面对这道题的第一想法是依照数学期望的定义来做,即依次求出某个点扔i次骰子能到达n点的概率,然后由期望的定义就可以求出答案了.但显然这在程序上是不可能实现的. 今天看了那篇文章后才知道自己的想法是大错特错的;求解这种问题应该采用一种递推的思路,即每次只考虑一次转移后当前状态的期望,然后我们依次考虑每个节点就可以得到一个方程组,然后就只需要求解这个方程组就行了. 当然对于如何求解这个方程组,我们可以采用高斯消元法,当然如果这个

CF148D--Bag of mice+概率期望dp

第一道概率期望dp:) 其实和一般的dp也差不多,只要状态选好就行了. 定义dp[i][j]表示还剩i只白老鼠j只黑老鼠时候公主赢得概率. 则:1.公主选白老鼠,直接赢,概率:i/(i+j) 2.公主选黑老鼠 1)龙选黑老鼠,逃走黑老鼠:概率:j/(i+j)*(j-1)/(i+j-1)*(j-2)/(i+j-2) 2)  龙选黑老鼠,逃走白老鼠:概率:j/(i+j)*(j-1)/(i+j-1)*i/(i+j-2) 3) 龙选白老鼠,这样公主是必输的,不用考虑 然后dp[i][j]等于以上概率之和