Dp(方案数——背包的升级版)

ftiasch 有 N 个物品, 体积分别是 W₁, W₂, ..., W_N。 由于她的疏忽, 第 i 个物品丢失了。 “要使用剩下的N - 1 物品装满容积为 x 的背包，有几种方法呢？” -- 这是经典的问题了。她把答案记为 Count(i, x) ，想要得到所有1 <= i <= N, 1 <= x <= M的 Count(i, x) 表格。

输入

第1行：两个整数 N (1 ≤ N ≤ 2 × 10³) 和 M (1 ≤ M ≤ 2 × 10³)，物品的数量和最大的容积。

第2行： N 个整数 W₁, W₂, ..., W_N, 物品的体积。

输出

一个 N × M 的矩阵， Count(i, x)的末位数字。

样例输入

3 2
1 1 2

样例输出

11
11
21

提示

如果物品3丢失的话，只有一种方法装满容量是2的背包，即选择物品1和物品2。

这道题，一眼看的出来，是方案数的背包的变形题目，怎么去做呢？
我首先就按照方案数背包的方案去做

把每次从n中物品中选择除了第k中物品以外的物品，分别放进j的背包中，代码如下，但是Tle了...

#include<iostream>
#include<stdio.h>
#include<cmath>
#include<cstring>
#define LL long long
#include<cstdio>
#define ref(i,x,y) for(int i=x;i<=y;i++)
#define def(i,x,y) for(int i=x;i>=y;i--)
#define ini(a,i) memset(a,i,sizeof a);
#define MAX_N 20003
using namespace std;
int dp[MAX_N];
int n,m;
int w[MAX_N];
int main()
{
//    freopen("F:\\cb代码文件\\input\\input.txt","r",stdin);
    while(~scanf("%d%d",&n,&m))
    {
      ref(i,1,n)cin>>w[i];
      ref(k,1,n)
      {
            ref(j,0,m)dp[j]=0;
            dp[0]=1;
          ref(i,1,n)
          {
              if(k!=i)
              {
                  def(j,m,w[i])dp[j]=(dp[j]+dp[j-w[i]])%10;
              }
          }
          ref(j,1,m)cout<<dp[j]%10;cout<<endl;
      }
    }
    return 0;
}

然后我再想这优化一下，因为当两种重量相同的物品丢失的时候，没必要算两遍，所以，就用一个数组坐下标记，把那些已经做了相关的操作的背包标记下，后边如果发现碰到一样的时候，直接就可以输出了，没必要还继续选上了，所以再来代码：

#include<iostream>
#include<stdio.h>
#include<cmath>
#include<cstring>
#define LL long long
#include<cstdio>
#define ref(i,x,y) for(int i=x;i<=y;i++)
#define def(i,x,y) for(int i=x;i>=y;i--)
#define ini(a,i) memset(a,i,sizeof a);
#define MAX_N 20003
using namespace std;
int dp[MAX_N][MAX_N];
int n,m;
int w[MAX_N];
bool v[MAX_N];
int main()
{
//    freopen("F:\\cb代码文件\\input\\input.txt","r",stdin);
    while(~scanf("%d%d",&n,&m))
    {
        ref(i,1,n)
        {
            cin>>w[i];
            v[w[i]]=false;
        }
        ref(k,1,n)
        {
            if(!v[w[k]])
            {
                v[w[k]]=true;
                ref(j,0,m)dp[w[k]][j]=0;
                dp[w[k]][0]=1;
                ref(i,1,n)
                {
                    if(k!=i)
                    {
                        def(j,m,w[i])dp[w[k]][j]=(dp[w[k]][j]+dp[w[k]][j-w[i]])%10;
                    }
                }
            }
            ref(j,1,m)cout<<dp[w[k]][j]%10;
            cout<<endl;
        }
    }
    return 0;
}

结果还是TLE了，哎，这道题我也算是撕开了，然后我想，最后的结果只需要输出个位数，我就反过来想，是不是这个结果是有规律的，也就是说，每次输入的某几组数据，有关系，那么输出的也有关系呢？这是一个公式或者是像素数表那样的推广型的简化的题？后来也通过一些数据，测试了许久，没发现什么可以总结出来的规律，所以最后实在不行了，就看了别人的代码：

简单的总结下别人的代码，怎么想的呢？

就是使用两个数组（二维的）当热，在这道题里都可以变成一维的数组。

用dp[i][j]表示除了第i个礼物以外，总共花费j的体积能够组起来的最大的方案数；

f[i][j]表示前i个礼物，总共花费j的体积能够组起来的最大的方案数；
那么就有这一个公式：

当j<w[i]时，dp[i][j]=f[i][j];

当w[i]<=j<=m的时候，dp[i][j]=f[n][j]-dp[i][j-w[i]];

当然这里可以换成一维数组：

dp[j]=f[j]-dp[j-w[i]];
另外温馨提下，因为最后的结果是需要控制cout(i,x)的个位数，那么对于上边的都需要对10取模，否则肯定会wa的，因为我也因为这个wa了几次。

还有一个问题，对于dp[i][j]=f[n][j]-dp[i][j-w[i]]怎么取模呢？注意，只能够这样：

dp[i][j]=(f[n][j]-dp[i][j-w[i]]+10)%10;因为这里的f[n][j]的个位数可能比dp[i][j-w[i]]小，那么就会出现负数，这样肯定是不合理的。。。

所以最后的能够A的代码：

#include<iostream>
#include<stdio.h>
#include<cmath>
#include<cstring>
#define LL long long
#include<cstdio>
#define ref(i,x,y) for(int i=x;i<=y;i++)
#define def(i,x,y) for(int i=x;i>=y;i--)
#define ini(a,i) memset(a,i,sizeof a);
#define MAX_N 2005
using namespace std;
int dp[MAX_N],f[MAX_N];
int n,m;
int w[MAX_N];
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if (ch=='-') f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int main()
{
//    freopen("F:\\cb代码文件\\input\\input.txt","r",stdin);
    while(~scanf("%d%d",&n,&m))
    {
        ref(i,1,n)w[i]=read();

        ini(f,0);

        f[0]=1;
        ref(i,1,n)def(j,m,w[i])f[j]=(f[j]+f[j-w[i]])%10;

        ref(i,1,n)
        {
            ref(j,0,w[i]-1)dp[j]=f[j];
            ref(j,w[i],m)dp[j]=(f[j]-dp[j-w[i]]+10)%10;
            ref(j,1,m)printf("%d",dp[j]%10);cout<<endl;
        }
    }
    return 0;
}