[CodeForces 543A]Writing Code[DP]

题目链接： [CodeForces 543A]Writing Code[DP]

题意分析：

n个程序员合作写m行代码，第i个程序员每次写一行会产生a[i]个bug，程序员顺序工作，1工作之后2工作，如此类推，现在要求总bug数不得超过b。问：写完m行代码，总bug数不超过b的方案有多少种？

解题思路：

首先我们试着定义一个状态，由于程序员顺序工作，那么我们定义dp[i][j]为写了i行代码，有j个bug的方案数，转移就是上个程序员写0~i行代码，感觉可以转移诶。。。。。然后深入分析，这样子的话，状态数会重叠。。。。。所以代表我们思考的状态不足够表达，那么试着再增加一维，变成dp[i][j][k]：到第i个程序员，项目已经完成了j行代码，出现了k个bug的方案数，嗯，这样就没有重叠了，状态可行，dp[i][j][k]就会由dp[i - 1][j][k](第i个程序员不写代码）和dp[i][j - x][k - x * a[i]]（第i个程序员写了x行代码, x > 0）转移而来。

怎么写程序呢？首先500*500*500的int已经是400MB的内存了，这里就要想着优化下；其次，循环怎么写？

对于问题1：观察发现状态dp[i][][]是由dp[i - 1][][]和dp[i][][]转移来的，只涉及到上一部分，所以可以滚动数组，就可以控制在内存限制之内了。

对于问题2：第二种情况中，主要是怎么处理dp[i][j - x][k - x * a[i]]。我们考虑dp[i][j - x][k - x * a[i]]是由什么转移而来的，至少包括dp[i][j - x - 1][k - (x+1)*a[i]]转移而来，这个又是之前的转移所要包含的了，所以说，只需要让dp[i][j][k]由dp[i][j - 1][k - a[i]]转移而来就行了。

个人感受：

用记忆化写了二维的，发现少了状态，然后该改改。最后不知道怎么处理dp[i][j - x][k - x *a[i]]。

具体代码如下：

#include<algorithm>
#include<cctype>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iomanip>
#include<iostream>
#include<map>
#include<queue>
#include<set>
#include<sstream>
#include<stack>
#include<string>
#define ll long long
#define pr(x) cout << #x << " = " << (x) << '\n';
using namespace std;

const int INF = 0x7f7f7f7f;
const int MAXN = 511;

int mod;
int dp[2][MAXN][MAXN], a[MAXN];

int main()
{
    int n, m, b;
    while (cin >> n >> m >> b >> mod) {
        for (int i = 1; i <= n; ++i) cin >> a[i];
        memset(dp, 0, sizeof dp);
        dp[0][0][0] = 1;
        for (int i = 1; i <= n; ++i) {
            int p = i & 1;
            for (int j = 0; j <= m; ++j) {
                for (int k = 0; k <= b; ++k) {
                    dp[p][j][k] = dp[p ^ 1][j][k];
                    if (j && k >= a[i])
                        dp[p][j][k] = (dp[p][j][k] + dp[p][j - 1][k - a[i]]) % mod;
                }
            }
        }

        int ans = 0;
        for (int i = 0; i <= b; ++i) {
            ans = (ans + dp[n & 1][m][i]) % mod;
        }
        cout << ans << '\n';
    }
    return 0;
}