完全背包问题

这个问题和01背包问题就在于一个物品可以无限次取

那么 c[i][j] = max(c[i][j], c[i][j-a[i]]+b[i],  c[i][j - 2 * a[i]] + 2 * b[i] --------）

f[i][j] = max(f[i][j],f[i-1][j-v[i]]+w[i]);//01背包

f[i][j] = max(f[i][j],f[i][j-v[i]]+w[i]);//完全背包问题

和01 背包问题 就在于这个第i个物品取多少次

f[i , j ] = max( f[i-1,j] , f[i-1,j-v]+w ,  f[i-1,j-2*v]+2*w , f[i-1,j-3*v]+3*w , .....)
f[i , j-v]= max(            f[i-1,j-v]   ,  f[i-1,j-2*v] + w , f[i-1,j-3*v]+2*w , .....)
由上两式，可得出如下递推关系： 
                        f[i][j]=max(f[i,j-v]+w , f[i-1][j])

 所以代码就变为

#include<iostream>
using namespace std;
const int N = 1010;
int f[N];
int v[N],w[N];
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i = 1 ; i <= n ;i ++)
    {
        cin>>v[i]>>w[i];
    }

    for(int i = 1 ; i<=n ;i++)
    for(int j = v[i] ; j<=m ;j++)
    {
            f[j] = max(f[j],f[j-v[i]]+w[i]); // 不用回到第i-1个位置了 只需要在第i个位置 剩余j个空间 进行再取  也因此 这里 j 必须 从小到大  因为 你当前的数据 是要用到前边的数据的
    }
    cout<<f[m]<<endl;
}

优化后就变为

#include<iostream>
using namespace std;
int n, m;
const int MX = 1e3;
int a[MX+10], b[MX+10];
int c[MX+10];
int main()
{
    scanf("%d %d",&n, &m);
    for(int i = 1; i <= n; i++)
    {
        scanf("%d %d", &a[i], &b[i]);
    }
    for(int i = 1; i <= n; i++)
    {
        for(int j = a[i]; j <= m; j++)
        {
            c[j] = max(c[j], c[j-a[i]] + b[i]);
        }
    }
    printf("%d",c[m]);
    return 0;
}

这道题 还有一种思路 就是将完全背包完全拆解 变成 01背包 当然同样使用于一些多重背包问题，不过就是牺牲了时间

还有就是 在优化的时候 一定要清楚顺序 所以 在能够确保通过后再考虑进行优化，  优化的顺序错了一点可能就没有AC了

for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            if(j >= a[i])
            c[j] = max(c[j], c[j-a[i]]+b[i]);
            cout << "c[" << j << "] =" << c[j] << ' ';
        }
        cout << endl;
    }

for(int i = 1; i <= n; i++)
    {
        for(int j = a[i]; j <= m; j++)
        {
            c[j] = max(c[j], c[j-a[i]]+b[i]);
            cout << "c[" << j << "] =" << c[j] << ' ';
        }
        cout << endl;
    }

 其实前两个代码块的意思差不多  只是如果第j个背包的容量小于这个物品的体积 就不用考虑了

这两块代码 都是从小背包往大背包装

for(int i = 1; i <= n; i++)
    {
        for(int j = m; j >= a[i]; j--)
        {
            c[j] = max(c[j], c[j-a[i]]+b[i]);
            cout << "c[" << j << "] =" << c[j] << ' ';
        }
        cout << endl;
    }
    cout << endl;

for(int i = 1; i <= n; i++)
    {
        for(int j = m; j >= 1; j--)
        {
            if(j >= a[i])
            c[j] = max(c[j], c[j-a[i]]+b[i]);
            cout << "c[" << j << "] =" << c[j] << ' ';
        }
        cout << endl;
    }

而这里再从大往小装 答案就会错误

为什么：  01 背包只能装一次 所以 从小往大 会出现重复装 比如物体A 体积为1 价值为 2

我在C[1] 装完后  在C[2] 这个包里 先把C[1] 放进去 剩下的空间足够 又放了一次A
所以出现 A装多次 故不可以  而倒序来的话 则是 第J个包 前面的包 都是针对前 i-1个物品的最大价值， 而我 第J个包 装不装 这第i 个物品 前面的背包都没有装这个物品 

而 在完全背包中则不同 和上面正好相反 我放进去C[1] 后 如果还能再装一个  那我 还可以再

放一个A 因此 正序是可以的 

为什么从大往小就不行了呢：

注意 这里的获得最大值的 方式是  我这第J个背包 没装 这个物品A  和装完物品A后 剩下的 体积再去装最大价值的物品 ， 然后两者比较取最大值 所以 能够保证 第J个背包一定取得为最大值， 而如果你倒序来的话  第J-A[I]个背包 都不能保证是最大值 自然也不能保证这第J个背包取最大值了