ZOJ3380 Patchouli's Spell Cards C++版(概率DP+大数)

最新推荐文章于 2024-05-12 19:49:36 发布
最新推荐文章于 2024-05-12 19:49:36 发布
阅读量340 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sun_hongjia/article/details/80626740
版权

题意题解不说了，这里主要讲用C++大数

为了节省时间使用了进制压缩，使用long long数组，进制1e9，使进制的平方在long long范围内

用len记数字位数，保证无前导零，方便计算，最低位存在number[0]中，number数组开到26(开25返回Segmentation Fault)

operator定义运算规则，这里+ - * / % == !=都进行了定义

1290ms 4836KB

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
const long long mod=1000000000;
struct biginteger
{
    long long number[26];
    int len;
    biginteger operator+(biginteger &b)
    {
        int i,root=max(len,b.len),Len=1;
        biginteger ans;
        memset(ans.number,0,sizeof(ans.number));
        ans.len=1;
        for(i=0; i<root||ans.number[i]; i++)
        {
            ans.number[i]+=number[i]+b.number[i];
            if(ans.number[i]>=mod)
            {
                ans.number[i+1]+=ans.number[i]/mod;
                ans.number[i]%=mod;
            }
            if(ans.number[i])
                Len=i;
        }
        ans.len=Len+1;
        return ans;
    }
    biginteger operator-(biginteger &b)
    {
        int i,root=max(len,b.len),Len=0;
        biginteger ans;
        memset(ans.number,0,sizeof(ans.number));
        ans.len=1;
        for(i=0; i<root; i++)
        {
            ans.number[i]+=number[i]-b.number[i];
            if(ans.number[i]<0)
            {
                ans.number[i+1]-=1;
                ans.number[i]+=mod;
            }
            if(ans.number[i])
                Len=i;
        }
        ans.len=Len+1;
        return ans;
    }
    biginteger operator*(biginteger &b)
    {
        int i,j,root=0;
        biginteger ans;
        memset(ans.number,0,sizeof(ans.number));
        ans.len=1;
        for(i=0; i<len; i++)
        {
            for(j=0; j<b.len; j++)
                ans.number[i+j]+=number[i]*b.number[j];
        }
        for(i=0; i<=len+b.len||ans.number[i]; i++)
        {
            if(ans.number[i]>=mod)
            {
                ans.number[i+1]+=ans.number[i]/mod;
                ans.number[i]%=mod;
            }
            if(ans.number[i])
                root=i;
        }
        ans.len=root+1;
        return ans;
    }
    bool Greater(biginteger b)
    {
        if(len>b.len)
            return true;
        if(len<b.len)
            return false;
        int i;
        for(i=len-1; i>=0; i--)
        {
            if(number[i]>b.number[i])
                return true;
            if(number[i]<b.number[i])
                return false;
        }
        return true;
    }
    biginteger operator/(biginteger &b)
    {
        biginteger ans_quotient;
        biginteger ans_remainder;
        memset(ans_quotient.number,0,sizeof(ans_quotient.number));
        ans_quotient.len=1;
        memset(ans_remainder.number,0,sizeof(ans_remainder.number));
        ans_remainder.len=1;
        biginteger temp;
        int i,j,root=0;
        long long w,head=0,l,r,mid;
        for(i=len-1; i>=b.len-1; i--)
        {
            head*=mod;
            head+=number[i];
            l=head/(b.number[b.len-1]+1);
            r=head/b.number[b.len-1];
            while(l<=r)
            {
                mid=(l+r)/2;
                memset(temp.number,0,sizeof(temp.number));
                temp.len=1;
                temp.number[i-b.len+1]=mid;
                temp.len=i-b.len+2;
                temp=temp*b;
                if(Greater(temp))
                    l=mid+1;
                else
                    r=mid-1;
            }
            w=r;
            memset(temp.number,0,sizeof(temp.number));
            temp.len=1;
            temp.number[i-b.len+1]=w;
            temp.len=i-b.len+2;
            temp=temp*b;
            int xroot=max(len,temp.len);
            for(j=0; j<xroot; j++)
            {
                number[j]-=temp.number[j];
                if(number[j]<0)
                {
                    number[j+1]-=1;
                    number[j]+=mod;
                }
                if(number[j])
                    len=j+1;
            }
            ans_quotient.number[i-b.len+1]=w;
            head=number[i];
            if(root==0&&w!=0)
                root=i-b.len+2;
        }
        ans_quotient.len=max(root,1);
        for(i=0; i<len; i++)
            ans_remainder.number[i]=number[i];
        ans_remainder.len=1;
        for(i=len-1; i>=0; i--)
        {
            if(ans_remainder.number[i])
            {
                ans_remainder.len=i+1;
                break;
            }
        }
        return ans_quotient;
    }
    biginteger operator%(biginteger &b)
    {
        biginteger ans_quotient;
        biginteger ans_remainder;
        memset(ans_quotient.number,0,sizeof(ans_quotient.number));
        ans_quotient.len=1;
        memset(ans_remainder.number,0,sizeof(ans_remainder.number));
        ans_remainder.len=1;
        biginteger temp;
        int i,j,root=0;
        long long w,head=0,l,r,mid;
        for(i=len-1; i>=b.len-1; i--)
        {
            head*=mod;
            head+=number[i];
            l=head/(b.number[b.len-1]+1);
            r=head/b.number[b.len-1];
            while(l<=r)
            {
                mid=(l+r)/2;
                memset(temp.number,0,sizeof(temp.number));
                temp.len=1;
                temp.number[i-b.len+1]=mid;
                temp.len=i-b.len+2;
                temp=temp*b;
                if(Greater(temp))
                    l=mid+1;
                else
                    r=mid-1;
            }
            w=r;
            memset(temp.number,0,sizeof(temp.number));
            temp.len=1;
            temp.number[i-b.len+1]=w;
            temp.len=i-b.len+2;
            temp=temp*b;
            int xroot=max(len,temp.len);
            for(j=0; j<xroot; j++)
            {
                number[j]-=temp.number[j];
                if(number[j]<0)
                {
                    number[j+1]-=1;
                    number[j]+=mod;
                }
                if(number[j])
                    len=j+1;
            }
            ans_quotient.number[i-b.len+1]=w;
            head=number[i];
            if(root==0&&w!=0)
                root=i-b.len+2;
        }
        ans_quotient.len=max(root,1);
        for(i=0; i<len; i++)
            ans_remainder.number[i]=number[i];
        ans_remainder.len=1;
        for(i=len-1; i>=0; i--)
        {
            if(ans_remainder.number[i])
            {
                ans_remainder.len=i+1;
                break;
            }
        }
        return ans_remainder;
    }
    bool operator==(biginteger &b)
    {
        if(len!=b.len)
            return false;
        int i;
        for(i=0; i<len; i++)
        {
            if(number[i]!=b.number[i])
                return false;
        }
        return true;
    }
    bool operator!=(biginteger &b)
    {
        if(len!=b.len)
            return true;
        int i;
        for(i=0; i<len; i++)
        {
            if(number[i]!=b.number[i])
                return true;
        }
        return false;
    }
} c[105][105],dp[105][105],zero,one;
void Print(biginteger a);
biginteger Gcd(biginteger a,biginteger b)
{
    while(b!=zero)
    {
        biginteger temp=b;
        b=a%b;
        a=temp;
    }
    return a;
}
void Print(biginteger a)
{
    int i;
    printf("%lld",a.number[a.len-1]);
    for(i=a.len-2; i>=0; i--)
        printf("%09lld",a.number[i]);
}
int main()
{
    one.len=1;
    one.number[0]=1;
    zero.len=1;
    int i,j,k;
    for(i=0; i<=100; i++)
        c[i][0]=c[i][i]=one;
    for(i=2; i<=100; i++)
    {
        for(j=1; j<i; j++)
            c[i][j]=c[i-1][j-1]+c[i-1][j];
    }
    long long n,m,l;
    while(~scanf("%lld%lld%lld",&m,&n,&l))
    {
        if(l>m)
        {
            printf("mukyu~\n");
            continue;
        }
        for(i=0; i<=100; i++)
        {
            for(j=0; j<=100; j++)
                dp[i][j]=zero;
        }
        dp[0][0]=one;
        biginteger ans=zero;
        for(i=1; i<=n; i++)
        {
            for(j=1; j<=m; j++)
            {
                for(k=0; k<=j&&k<l; k++)
                {
                    biginteger temp=dp[i-1][j-k]*c[m-(j-k)][k];
                    dp[i][j]=dp[i][j]+temp;
                }
            }
            ans=ans+dp[i][m];
        }
        biginteger sum=one;
        for(i=0; i<m; i++)
        {
            biginteger x=zero;
            x.number[0]=n;
            sum=sum*x;
        }
        ans=sum-ans;
        biginteger gcd=Gcd(sum,ans);
        Print(ans/gcd);
        printf("/");
        Print(sum/gcd);
        printf("\n");
    }
    return 0;
}

sun_hongjia
关注
C++ Zoj1045 HangOver
ChanJose的博客
12-28 436
题目大意： 输入： 输入一组测试数据c，c的取值范围位：0.01~5.20(c包含3个数字) 输出：（在一张桌上放一叠卡片，问刚好超过给定长度的卡片数） 每张卡片伸出的长度依次分别为：1/2 1/3 1/4 1/5 …. 1/n 然后对于每组测试数据c，看1/2 + 1/ 3 + 1/4 ….的和什么时候大于c时，输出此时所需卡片的数量 ...
C++ zoj2812 Quicksum
ChanJose的博客
12-28 321
题目大意： 输入：        每一行输入，只允许出现大写字母或者空格；        以“#”结束输入。 输出：        每一行中各个字母对应的数乘以该字母对应的位置，求它们的和 一、方法1: AC        把每行字符串存到字符数组中，然后进行相应的处理 #include &lt;iostream&gt; using namespace std; const...
概率dp 树形dp经典题目加解析
04-28
概率dp 树形dp经典题目加解析........高斯求期望...............
★ZOJ 3380 Patchouli's Spell Cards 详细题解 （递推+组合数求方案数）
K键盘里的青春K
03-25 1035
Patchouli's Spell Cards Time Limit: 7 Seconds      Memory Limit: 65536 KB Patchouli Knowledge, the unmoving great library, is a magician who has settled down in the Scarlet Devil Mansion (紅魔館)
c++概率dp——超实用的数据结构
yzc_qiuse的博客
11-25 1018
今天的文章就到这里啦，三连必回qwq！
概率dp
Code_BaiYE的博客
12-05 369
概率DP主要用于求解期望、概率等题目。 转移方程有时候比较灵活。 一般求概率是正推，求期望是逆推。通过题目可以体会到这点。 POJ-2096    Collecting Bugs Time Limit: 10000MS   Memory Limit: 64000K Total Submissions: 6481   Accepted: 3160
ZOJ3380- Patchouli's Spell Cards(概率DP+计数)
mowayao的专栏
07-03 977
Patchouli's Spell Cards Time Limit: 7 Seconds      Memory Limit: 65536 KB Patchouli Knowledge, the unmoving great library, is a magician who has settled down in the Scarlet Devil Mansion (紅魔館
ZOJ1002.rar_Windows编程_C/C++_
08-11
标题中的"ZOJ1002.rar"是一个竞赛编程题目，通常在在线判题系统如ZOJ（Zhejiang Online Judge）中出现。这个题目涉及的是"Windows编程"，使用"C/C++"语言来实现。描述中提到的是利用类似于迪杰斯特拉（Dijkstra）...
ACM训练必备POJ ZOJ题目分类及解题思路
04-19
学习ACM程序设计的朋友一定要看，这是训练必备的POJ ZOJ题目分类及解题思路
ZOJ 2317 高精度+状压DP+矩阵快速幂
【洛风城】
10-01 467
题意：给你一个NxM的格子，每个格子可以涂黑色或者白色，但是不允许renyi
ZOJ 3380 Patchouli's Spell Cards( 概率DP)
Neutralzz的博客
07-12 304
题意：用n个数填充m个位置，问有大于等于l个相同数字的概率。 这个题看了很多题解，大部分代码都是有点问题的，一开始dp的状态都是一样的。（具体见下） 思路：设dp[i][j] 为用前i个数填充j个位置的方案数。 则dp[i][j] = sigma(dp[i-1][j-k] * C[m-j+k][k]) (k >= 0 && k 最后的结果应该是(n^m - dp[n][m]) /  n^
Zoj 3380 Patchouli's Spell Cards (概率dp)
Jinx Jinx again
04-10 837
题目大意： 用(1 2 3 ... n) n个数填充 m个位置，问最少相同的数字出现的数量不少于I 的概率 思路分析： 逆向思考，求铺满最多的数量不够I 个的方案数。 每次用一个数字去铺，铺M个位置，每个数字最多铺 不够I个。 dp[i][j]表示枚举到了第i个数字，前i个数字铺了j个位置的方案数。 考虑到组合计数 用Java import java.util.*;
ZOJ 3380 Patchouli's Spell Cards [基础概率DP+大数]
Rain
04-26 483
Patchouli's Spell Cards Time Limit: 7 Seconds      Memory Limit: 65536 KB Patchouli Knowledge, the unmoving great library, is a magician who has settled down in the Scarlet Devil Mansion (紅魔館).
收集邮票C++题目【概率期望DP+数学推导】
最新发布
m0_66786097的博客
05-12 827
C++题目：【概率期望DP+数学推导】收集邮票！O(n) 解决
ZOJ 3380 Patchouli's Spell Cards [基础DP+大数]
Asuna_acmer
12-01 658
Patchouli Knowledge, the unmoving great library, is a magician who has settled down in the Scarlet Devil Mansion (紅魔館). —— M个不同的球，N种颜色，现在给球染色，问至少有L个球同一种颜色的概率。
ZOJ 3380 Patchouli's Spell Cards 概率DP
s_h_r
10-10 509
题意：给你m个位置，每个位置放一个数，区间为1～n，问你至少有L个位置是一样的数的概率，结果用分数表示思路：这题我们从反向入手，dp[i][j]代表前i个数，放到j个位置，且没有L个或以上的位置有相同的组合情况，最后用n^m减去即可这道题要用大数，正好这两天在乱搞python。。。import sysC = [([0] * 110) for i in range(110)] for i in ran
期望/概率dp
yueazero的博客
10-04 361
1、从前至后，常用于求概率，需要起始状态已知。2、从后至前，常用于求期望，需要终止状态已知。离散型概率分布。其中一种定义为：在n次中，试验k次才得到第一次成功的机率。详细地说是：前k-1次皆失败，第k次成功的概率。在伯努利试验中，成功的概率为p，若ξ表示出现首次成功时的试验次数，则ξ是离散型随机变量，它只取正整数，且有P(ξ=k)=(k=1，2，…，0
概率dp总结
qq_43653111的博客
03-11 584
概率dp总结 概率一般是正推，期望一般是逆推. 很多题要推公式，不能上去就dp. 可以利用矩阵快速幂加速，高斯消元解方程，待定系数法推公式。 POJ3744 题意：起点是1，每次有p的概率走一步，或者1-p的概率走两步，路径上会有地雷，问你走出去的概率。 思路：dp[1]=1,dp[i]=dp[i-1] * p+dp[i-2]*(i-p); 范围这么大，可以矩阵快速幂优化递推，当时路径上点...
概率dp专题 博客
20164225的博客
05-02 533
文章结合：https://blog.csdn.net/chenzhenyu123456/article/details/51147314   1.poj 2096 Collecting Bugs 【概率DP】【逆向递推求期望】 题意很简单：一个软件有S个系统，但会产生N种bug。一个人一天可以发现一个bug,这个bug既属于某一个系统，又属于某一个分类。每个bug属于某个系统的概率是1/S,...
C++代码解决ZOJ问题1002, 1091, 1789
"C++代码实现解决ZOJ1002、1091、1789三道编程题" 这段代码是用C++编写的，主要目的是解决ZOJ（在线判题系统ZeroJudge）中的三道题目：1002、1091和1789。代码中使用了深度优先搜索（DFS）算法来寻找最优解。虽然...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值