洛谷【P1541】乌龟棋

题目背景

小明过生日的时候，爸爸送给他一副乌龟棋当作礼物。

题目描述

乌龟棋的棋盘是一行N个格子，每个格子上一个分数（非负整数）。棋盘第1格是唯一的起点，第N格是终点，游戏要求玩家控制一个乌龟棋子从起点出发走到终点。

乌龟棋中M张爬行卡片，分成4种不同的类型（M张卡片中不一定包含所有4种类型的卡片，见样例），每种类型的卡片上分别标有1、2、3、4四个数字之一，表示使用这种卡片后，乌龟棋子将向前爬行相应的格子数。游戏中，玩家每次需要从所有的爬行卡片中选择一张之前没有使用过的爬行卡片，控制乌龟棋子前进相应的格子数，每张卡片只能使用一次。

游戏中，乌龟棋子自动获得起点格子的分数，并且在后续的爬行中每到达一个格子，就得到该格子相应的分数。玩家最终游戏得分就是乌龟棋子从起点到终点过程中到过的所有格子的分数总和。

很明显，用不同的爬行卡片使用顺序会使得最终游戏的得分不同，小明想要找到一种卡片使用顺序使得最终游戏得分最多。

现在，告诉你棋盘上每个格子的分数和所有的爬行卡片，你能告诉小明，他最多能得到多少分吗？

输入输出格式

输入格式：

输入文件的每行中两个数之间用一个空格隔开。

第1行2个正整数N和M，分别表示棋盘格子数和爬行卡片数。

第2行N个非负整数，a1a2……aN，其中ai表示棋盘第i个格子上的分数。

第3行M个整数，b1b2……bM，表示M张爬行卡片上的数字。

输入数据保证到达终点时刚好用光M张爬行卡片。

输出格式：

输出只有1行，1个整数，表示小明最多能得到的分数。

输入输出样例

输入样例#1：

9 5
6 10 14 2 8 8 18 5 17
1 3 1 2 1

输出样例#1：

73

说明

每个测试点1s

小明使用爬行卡片顺序为1，1，3，1，2，得到的分数为6+10+14+8+18+17=73。注意，由于起点是1，所以自动获得第1格的分数6。

对于30%的数据有1≤N≤30，1≤M≤12。

对于50%的数据有1≤N≤120，1≤M≤50，且4种爬行卡片，每种卡片的张数不会超过20。

对于100%的数据有1≤N≤350，1≤M≤120，且4种爬行卡片，每种卡片的张数不会超过40；0≤ai≤100，1≤i≤N；1≤bi≤4，1≤i≤M。

题解

一开始看的这道题时，我设计了如下的状态转移方程：
状态设计：F[i][a][b][c][d]代表走到第i格，四种卡片分别用了a，b，c，d张时的最大得分。
状态转移：F[i][a][b][c][d]=max { F[i-1][a-1][b][c][d] , F[i-2][a][b-1][c][d] , F[i-3][a][b][c-1][d] , F[i-4][a][b][c][d-1] } + A[i]（A[i]表示第i格的分数）
边界处理：F[1][0][0][0][0]=A[1]
然而。。。。。

为了解决MLE的问题，我用了滚动数组，核心代码如下：

 for(int i=1;i<=n;++i)
    for(int a=0;a<=c1;++a)
        for(int b=0;b<=c2;++b)
            for(int c=0;c<=c3;++c)
                for(int d=0;d<=c4;++d)
                    {
                        int cur=i%5;
                        if(i>=2&&a) f[cur][a][b][c][d]=max(f[cur][a][b][c][d],f[(i+4)%5[a-1][b][c][d]+x[i]);
                        if(i>=3&&b) f[cur][a][b][c][d]=max(f[cur][a][b][c][d],f[(i+3)%5][a][b-1][c][d]+x[i]);
                        if(i>=4&&c) f[cur][a][b][c][d]=max(f[cur][a][b][c][d],f[(i+2)%5][a][b][c-1][d]+x[i]);
                        if(i>=5&&d) f[cur][a][b][c][d]=max(f[cur][a][b][c][d],f[(i+1)%5][a][b][c][d-1]+x[i]);
                    }

然而这只解决了空间问题，时间还是妥妥的炸：

后来又用了各种黑科技卡常（比如手动开O2【滑稽】），多过了一个点：

算算时间复杂度，350*40^4=896000000，已经接近1e9级别了，不T才怪。
后来看了题解，发现不用枚举i，枚举a，b，c，d的时候可以把当前位置i算出来,i=1+1*a+2*b+3*c+4*d
加1是因为起点是1。
于是，最终的满分做法：

状态设计：F[a][b][c][d]表示四种卡片分别用了a，b，c，d张时的最大得分

状态转移：F[a][b][c][d] = max { F[a-1][b][c][d] , F[a][b-1][c][d] , F[a][b][c-1][d] , F[a][b][c][d-1] } + A[1+1*a+2*b+3*c+4*d]

边界处理：F[0][0][0][0]=A[1]（一张卡也没用时只有起点的得分）

时间复杂度：O（card1*card2*card3*card4）（cardi代表第i种卡片的总张数）

40^4=2560000

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#define max(a,b) a>b?a:b
using namespace std;
const int maxn =353,maxm=123,maxp =43;
int x[maxn],b[maxm];
int f[maxp][maxp][maxp][maxp];
int m,n;
int main()
{
    int c1=0,c2=0,c3=0,c4=0;
    int ans=-1e9;
    bool flag=false;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) scanf("%d",&x[i]);
    for(int i=1;i<=m;i++) 
    {
        scanf("%d",&b[i]);
        switch(b[i])
        {
            case 1:c1++;break;
            case 2:c2++;break;
            case 3:c3++;break;
            case 4:c4++;break;
            default:break;
        }
    }
    f[0][0][0][0]=x[1];
    for(int a=0;a<=c1;++a)
    {
        for(int b=0;b<=c2;++b)
        {
            for(int c=0;c<=c3;++c)
            {
                for(int d=0;d<=c4;++d)
                {
                    if(a) f[a][b][c][d]=max(f[a][b][c][d],f[a-1][b][c][d]+x[1+a+b*2+c*3+d*4]);
                    if(b) f[a][b][c][d]=max(f[a][b][c][d],f[a][b-1][c][d]+x[1+a+b*2+c*3+d*4]);
                    if(c) f[a][b][c][d]=max(f[a][b][c][d],f[a][b][c-1][d]+x[1+a+b*2+c*3+d*4]);
                    if(d) f[a][b][c][d]=max(f[a][b][c][d],f[a][b][c][d-1]+x[1+a+b*2+c*3+d*4]);
                }
            }
        }
    }
    ans=f[c1][c2][c3][c4];
    printf("%d\n",ans);
    return 0;
}

终于A了!

总结

1.设计状态时要注意有没有多余的、可以舍弃的状态，减小空间复杂度和时间复杂度。

2.空间不够时记得使用滚动数组

3.我果然还是太弱了QwQ