百度之星2010复赛第二场第三题《蜗牛》

原创 于 2014-06-03 00:30:31 发布 · 1.1k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

探讨了一个经典的编程问题——蜗牛如何在限定时间内爬出不同深度的井，通过动态规划算法来计算所有可能的爬升与下滑组合。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

蜗牛 (时限：1000ms)

时间限制:12000ms
单点时限:6000ms
内存限制:256MB
问题描述
一只蜗牛某天早晨掉进了深为L尺的井中。蜗牛每天白天可以向上爬若干尺，晚上休息时会向下滑若干尺。蜗牛一旦到达井口或井底，便不再下滑。
假设蜗牛每天向上爬的尺数均为不超过10的正整数，而下滑的尺数为不超过5的正整数。蜗牛在第N天白天里(含第N天白天结束时)爬出了井，你的任务是统计有多少种可能的爬升/下滑情况。 对于两种爬升/下滑情况，当存在对应的白天上爬或者晚上下滑的尺数不同时，即视为不同的情况。
输入格式
第一行：井深L。其中L为正整数，且L<=100；
第二行：爬出的天数N。其中N为正整数，且N<=300；
输出格式
输出一个正整数，为可能的爬升/下滑情况总数。如不可能在N天白天里(含第N天白天结束时)爬出深为L的井，则应输出0。
样例1
输入：
27
3
输出：
6
解释：
输入指明井深为27。蜗牛掉下去后，在第3天白天爬出了井。一共有6种可能的上升/下滑情况组合：
(9, -1) (10, -1) 10  8+9+10=27
(10, -1) (9, -1) 10  9+8+10=27
(10, -1) (10, -1) 9  9+9+9=27
(10, -1) (10, -1) 10  9+9+10>27 (第3天白天未结束时，爬出了井)
(10, -1) (10, -2) 10  9+8+10=27
(10, -2) (10, -1) 10  8+9+10=27
样例2
输入：
5
4
输出：
5033
样例3
输入：
42
12
输出：
3106744105061936231
评分标准
本题有20组数据，每组数据结果正确的情况下，计算时间不得超过1秒。其中，75%的输入数据满足N<=12。

　　这道题大概是这次复赛中最水的题目，是一道简单的dp。设状态f(i, j)表示蜗牛用i天爬出深度为j的井的情况总数，注意到爬升和下滑的尺数分别只有10和5，故而可以枚举爬升和下滑的尺数，从第i天的情况推出第i + 1天的情况总数，在O(10 * 5 * N * L)的复杂度下完成计算。

　　在枚举下滑的尺数时要注意，蜗牛下滑到井底后不会再下滑；此外最后一天一定是在白天爬出，所以只爬升不下滑。因为方案数比较大，这道题需要高精度运算。此外如果把dp写成记忆化搜索的形式，极端数据下(如L = 100, N = 300)会爆栈，需要手动扩栈；在G++和VC++下扩栈方式不一致，这里不再多述。下面给出两种dp写法的标程。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

struct BigInt {
    const static int mod = 10000;
    const static int DLEN = 4;
    const static int MAXL = 1000;
    int a[MAXL], len;
    BigInt(int v = 0) {
        memset(a, 0, sizeof(a));
        len = 0;
        do {
            a[len++] = v % mod;
            v /= mod;
        }
        while(v);
    }
    BigInt(const char s[]) {
        memset(a, 0, sizeof(a));
        int L = strlen(s);
        len = L / DLEN;
        if(L % DLEN)
            ++len;
        int index = 0;
        for (int i = L - 1; i >= 0; i -= DLEN) {
            int t = 0, k = i - DLEN + 1;
            if(k < 0)
                k = 0;
            for (int j = k; j <= i; ++j)
                t = t * 10 + s[j] - '0';
            a[index++] = t;
        }
    }
    BigInt operator + (const BigInt &b) const {
        BigInt res;
        res.len = max(len, b.len);
        for (int i = 0; i <= res.len; ++i)
            res.a[i] = 0;
        for (int i = 0; i < res.len; ++i) {
            res.a[i] += (i < len ? a[i]: 0) + (i < b.len ? b.a[i] : 0);
            res.a[i + 1] += res.a[i] / mod;
            res.a[i] %= mod;
        }
        if(res.a[res.len] > 0)
            ++res.len;
        return res;
    }
    void output() {
        printf("%d", a[len - 1]);
        for (int i = len - 2; i >= 0; --i)
            printf("%04d", a[i]);
        putchar('\n');
    }
} ZERO(0);

BigInt dp[105][305];
int l, n;

int main() {
    while(~scanf("%d%d", &l, &n)) {
        for (int i = 0; i <= l; ++i)
            for (int j = 1; j <= n; ++j)
                dp[i][j] = ZERO;
        for (int i = min(10, l); i >= 1; --i)
            dp[i][1] = BigInt(11 - i);
        for (int j = 1; j < n; ++j)
            for (int i = 1; i <= l; ++i)
                for (int d = min(5, i - 1); d >= 1; --d)
                    for (int u = min(10, l - i + d); u >= 1; --u)
                        dp[i - d + u][j + 1] = dp[i - d + u][j + 1] + dp[i][j];
        dp[l][n].output();
    }
    return 0;
}
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

struct BigInt {
    const static int mod = 10000;
    const static int DLEN = 4;
    const static int MAXL = 1000;
    int a[MAXL], len;
    BigInt(int v = 0) {
        memset(a, 0, sizeof(a));
        len = 0;
        do {
            a[len++] = v % mod;
            v /= mod;
        }
        while(v);
    }
    BigInt(const char s[]) {
        memset(a, 0, sizeof(a));
        int L = strlen(s);
        len = L / DLEN;
        if(L % DLEN)
            ++len;
        int index = 0;
        for (int i = L - 1; i >= 0; i -= DLEN) {
            int t = 0, k = i - DLEN + 1;
            if(k < 0)
                k = 0;
            for (int j = k; j <= i; ++j)
                t = t * 10 + s[j] - '0';
            a[index++] = t;
        }
    }
    BigInt operator + (const BigInt &b) const {
        BigInt res;
        res.len = max(len, b.len);
        for (int i = 0; i <= res.len; ++i)
            res.a[i] = 0;
        for (int i = 0; i < res.len; ++i) {
            res.a[i] += (i < len ? a[i]: 0) + (i < b.len ? b.a[i] : 0);
            res.a[i + 1] += res.a[i] / mod;
            res.a[i] %= mod;
        }
        if(res.a[res.len] > 0)
            ++res.len;
        return res;
    }
    void output() {
        printf("%d", a[len - 1]);
        for (int i = len - 2; i >= 0; --i)
            printf("%04d", a[i]);
        putchar('\n');
    }
} ZERO(0);

BigInt dp[105][305];
bool mark[105][305];
int l, n;

BigInt dfs(int tl, int tn) {
    if(mark[tl][tn])
        return dp[tl][tn];
    mark[tl][tn] = true;
    if(tn == 1)
        return dp[tl][tn] = BigInt(max(tl - l + 11, 0));
    for (int u = min(10, l - tl - 1); u >= 1; --u)
        for (int d = min(5, tl + u); d >= 1; --d)
            dp[tl][tn] = dp[tl][tn] + dfs(tl + u - d, tn - 1);
    return dp[tl][tn];
}

int main() {
    // 内嵌汇编, G++扩栈
    int __size__ = 32 << 20; // 32MB
    char *__p__ = (char *)malloc(__size__) + __size__;
    __asm__("movl %0, %%esp\n" :: "r"(__p__));

    while(~scanf("%d%d", &l, &n)) {
        memset(mark, false, sizeof(mark));
        for (int i = 0; i <= l; ++i)
            for (int j = 1; j <= n; ++j)
                dp[i][j] = ZERO;
        dfs(0, n).output();
    }
    return 0;
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值