UVA12298 Super Poker II 递推

最新推荐文章于 2016-09-20 12:20:31 发布

笨君

最新推荐文章于 2016-09-20 12:20:31 发布

阅读量840

点赞数 2

分类专栏：各种题解文章标签：解题报告 ACM uva

本文链接：https://blog.csdn.net/moedane/article/details/37941059

版权

各种题解专栏收录该内容

4 篇文章 0 订阅

订阅专栏

博客详细介绍了如何解决UVA12298题目，该题目涉及使用合数扑克牌在限制条件下组成特定整数的方法数。博主分享了递推思路，并提供了代码实现，包括如何处理缺失的扑克牌和如何进行状态转移。

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

转载注明出处 http://blog.csdn.net/moedane

传送门 http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=3719

题意

你有无限种扑克牌，这些扑克牌上的数字都是合数（非素数），其中丢失了c张牌，每种牌有四种花色。求每种花色能且仅能用一张牌，能组成整数n的方法有多少种。询问一个区间[a,b]，输出组成n的方法数，n ∈ [a,b]

思路

原题好像是2011年湖南省赛，在今天队内训练赛中遇到了。现场不会做，也没有人做出来，后来百度也找不到题解，只好找到别人的contest看别人的ac代码，好不容易看懂了，发现就是一个递推式子，感觉好神~

说说解法：

数组f[i][j]表示用前i种花色能组成j的方法数。

这里还需要做出一个信息：对于每种花色，记录这种花色缺失的扑克牌。代码里用vector<int> ban[5]来记录。

把ban数组从小到大排好序之后，相邻的两个数之间的数就都是可用的。

于是可以这样转移：

        for(int i=1;i<4;i++)
        {
            for(int j=1;j<=b;j++)
            {
                int p = 1;
                while(ban[i][p] <= j && p < ban[i].size())
                {
                    f[i][j] += Sum(i-1, j - ban[i][p] + 1 , j - ban[i][p-1] - 1);
                    p ++;
                }
                f[i][j] += Sum(i-1, 1 , j - ban[i][p-1] - 1 );
                pre[i][j] = pre[i][j-1] + f[i][j];
            }
        }

举个例子来解释吧：

譬如我现在要算用前两种花色来构成20这个数，其中我有两个相邻的不可用的点是7，11；

那么我可以用的数的一个区间就是[8,10]；

而我需要构成20，那么我只需要在之前已经构成的数里面找[10,12]这个区间里面的任意一个数即可。

故f[i][j] += Sum(i-1, j - ban[i][p] + 1 , j - ban[i][p-1] - 1);

代码

#include <iostream>
#include <cstring>
#include <cstdio>
#include <string>
#include <algorithm>
#include <cmath>
#include <ctime>
#include <vector>
#include <queue>
#include <stack>
#include <fstream>
#include <map>
#include <set>
#define bug puts("here");

using namespace std;

typedef long long ll;

const int maxn = 50086;
const int maxm = 500010;
const ll mod =  1000000009;
const int inf = 0x3f3f3f3f;
const double PI = atan(1.0) * 4.0;
const double eps = 1e-9;

int a,b,c;
bool isp[maxn];
vector<int> ban[5]; // 每个花色不能取的数
ll f[5][maxn]; // f[i][j]表示用前i种花色达到数字j的方法数
ll pre[5][maxn]; // f的前缀和

void getPrime() // 打素数
{
    int tot = 0;
    memset(isp, true, sizeof isp);
    for(int i=2;i<maxn;i++){
        if(isp[i]){
            for(int j=2;j*i<maxn;j++)
                isp[i*j] = false;
        }
    }
}

int conv(char x)
{
    switch(x){
    case 'S': return 0;
    case 'H': return 1;
    case 'C': return 2;
    case 'D': return 3;
    }
}

void init()
{
    for(int i=0;i<4;i++) ban[i].clear();
    memset(f, 0 , sizeof f);
    memset(pre , 0 , sizeof pre);
}

ll Sum(int i,int l,int r) // 区间和
{
    if(l > r) return 0;
    if(r <= 0) return 0;
    if(l <= 0) return pre[i][r];
    return pre[i][r] - pre[i][l-1];
}

int main()
{
    getPrime();
    while(~scanf("%d%d%d",&a,&b,&c) && (a+b+c))
    {
        init();
        for(int i=0;i<c;i++){
            int t;
            char cc;
            scanf(" %d%c",&t,&cc);
            ban[conv(cc)].push_back(t);
        }
        for(int i=0;i<4;i++){
            for(int j=1;j<=b;j++){
                if(isp[j]) ban[i].push_back(j);
            }
            sort(ban[i].begin(), ban[i].end());
        }
        int last = 0;
        for(int i=1;i<=b;i++) // 初始只用一种花色的解
        {
            f[0][i] = 1;
            if(last < ban[0].size() && i == ban[0][last]){
                last ++;
                f[0][i] = 0;
            }
            pre[0][i] = pre[0][i-1] + f[0][i];
        }
        for(int i=1;i<4;i++)
        {
            for(int j=1;j<=b;j++)
            {
                int p = 1;
                while(ban[i][p] <= j && p < ban[i].size())
                {
                    f[i][j] += Sum(i-1, j - ban[i][p] + 1 , j - ban[i][p-1] - 1);
                    p ++;
                }
                f[i][j] += Sum(i-1, 1 , j - ban[i][p-1] - 1 );
                pre[i][j] = pre[i][j-1] + f[i][j];
            }
        }
        for(int i=a;i<=b;i++){
            printf("%lld\n",f[3][i]);
        }
        puts("");
    }
}