P1174打砖块

题目描述

小红很喜欢玩一个叫打砖块的游戏，这个游戏的规则如下：

在刚开始的时候，有 nn 行 mm 列的砖块，小红有 kk 发子弹。小红每次可以用一发子弹，打碎某一列当前处于这一列最下面的那块砖，并且得到相应的得分。（如图所示）

某些砖块在打碎以后，还可能将得到一发子弹的奖励。最后当所有的砖块都打碎了，或者小红没有子弹了，游戏结束。

小红在游戏开始之前，就已经知道每一块砖在打碎以后的得分，并且知道能不能得到一发奖励的子弹。小红想知道在这次游戏中她可能的最大得分，可是这个问题对于她来说太难了，你能帮帮她吗？

题目的几个要点

①即使每个砖块都有子弹奖励，也不会给你多出子弹来，只会弥补掉你这次打砖块用掉的那颗子弹
②同一列就必须从下打到上，但是不同列砖块打掉的顺序可以任意

解析

有后效性分组背包

1. 分组背包： 每个列可以选择从第n块打到第i块，这是一个物品组

2. 有后效性： 对于第j列的第i 块砖块，a[i][j]，这个砖块有子弹奖励，那么存在先打这个砖块拿奖励的1颗子弹再打前面砖块。也可以拿前面的某一列打的某块砖的奖励的一颗子弹（那颗子弹没用掉）现在拿来打我这一列的a[i][j]个砖块

3. 消除后效性： 一般采用加状态（标记）的方法，针对上面的可能的状态，可以增加一个当前这个砖块子弹奖励用了或者没用两个状态，分别用0，1表示；

4. 令$$dp[j][l][0]$$为打到第j列，用了l颗子弹，子弹最后打的那个砖块的子弹奖励已经被用掉。
   
   那么$$dp[j][l][1]$$就是子弹奖励没有被用掉 。
   
   令$$use[i][j]$$ 表示第j列从第n块砖打到第i块砖只少要用的子弹数目。
   
   令$$pre[i][j]$$ 表示第j列从第n块转打到第i块砖得到的分数和。

5. 针对上面两种有后效性的情况可以这样消除

   ①这个砖块有子弹奖励，那么存在先打这个砖块拿奖励的1颗子弹再打前面砖块的方案 $$dp[j][l][0]=max(dp[j][l][0],dp[j-1][l-use[i][j]+1][0]+pre[i][j]);$$
   ②拿前面的打的某一列里的奖励的一颗子弹（那颗子弹没用掉）现在拿来打我这一列的a[i][j]个砖块，也就是打当前j列的$$pre[i][j]$$实际上只用了$$use[i][j]-1$$个子弹
   所以$$dp[j][l][0]=max(dp[j][l][0],dp[j-1][l-use[i][j]+1][1]+pre[i][j]);$$

完整代码

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
const int N = 220;
int n, m, k;

ll dp[N][N][2], pre[N][N];
int use[N][N], g[N][N];
char s[2];

void init()
{
    for (int j = 1; j <= m; ++j)
    {
        //数组不用再初始化0，但是防止上一组输入 n 刚好是 n + 1
        use[n + 1][j] = pre[n + 1][j] = g[n + 1][j] = 0;

        for (int i = n; i; --i)
        {
            if (!g[i + 1][j])//如果第 i + 1 块没有子弹奖励，那么打到i + 1子弹数++
                use[i][j] = use[i + 1][j] + 1;
            else            //i + 1有子弹奖励，用奖励的子弹
                use[i][j] = use[i + 1][j];
            pre[i][j] += pre[i + 1][j];
        }
    }
}

void solve()
{
    for (int j = 1; j <= m; ++j)
    {
        for (int i = n; i; --i)
        {
            for (int l = use[i][j]; l <= k; ++l)
            {
                //当前列一个砖都不打的情况
                dp[j][l][0] = max(dp[j][l][0], dp[j - 1][l][0]);
                dp[j][l][1] = max(dp[j][l][1], dp[j - 1][l][1]);
                
                if (g[i][j])//当前砖有子弹奖励
                {
                    //可以借给前面 先打j列再打 j列之前的
                    dp[j][l][0] = max(dp[j][l][0], dp[j - 1][l - use[i][j] + 1][0] + pre[i][j]);
                    //不借给前面 保留这次机会
                    dp[j][l][1] = max(dp[j][l][1], dp[j - 1][l - use[i][j]][0] + pre[i][j]);
                }
                //向前面借1个  前面有剩余的子弹
                ll x = dp[j - 1][l - use[i][j] + 1][1];
                if (x)//能借一定大于不能借的 dp[j][i + 1][1] > dp[j][i][0]
                {
                    dp[j][l][0] = max(dp[j][l][0], x + pre[i][j]);
                    if (g[i][j])//i,j块砖块奖励了子弹时才更新
                        dp[j][l][1] = max(dp[j][l][1], x + pre[i][j]);
                } 
                else//向前面借不了 
                {
                    dp[j][l][0] = max(dp[j][l][0], dp[j - 1][l - use[i][j]][0] + pre[i][j]);
                }
            }
        }
    }
}

int main()
{

    //freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);

  

        scanf("%d%d%d", &n, &m, &k);
        for (int i = 1; i <= n; ++i)
        {
            for (int j = 1; j <= m; ++j)
            {
                scanf("%d %s", &pre[i][j], s);
                g[i][j] = s[0] == 'Y' ? 1 : 0;
            }
        }

        init();
        solve();
        printf("%lld\n", dp[m][k][0]);
     

    return 0;
}