Problem Description

There are N items and a backpack with a capacity W. The most N [I] pieces of the i-I item are available, each weight is W [i], and the value is V [I]. Solving which items will be loaded into the backpack to make the weight of these items do not exceed the backpack capacity, and the total value is maximum.

analysis:

Two most basic algorithms:

1. Use a triple cycle to reciprocate:
State transition type is:dp[i][j]=max{dp[i-1][j-k*w[i]]+k*v[i]|0<=k<=n[i]}

The key code is as follows:

void solve()
{
    for(int i=0; i<N; i++)
    {
        for(int j=0; j<=W; j++)
        {
            for(int k=0; k<=a[i] && k*w[i]<=j; k++)
            {
                dp[i+1][j] = max(dp[i][j], dp[i][j-k*w[i]]+k*v[i]); 
            }
        }
    }
    printf("%d\n",dp[N][W]);
}

However, the complexity is O (V * σn [i]), the efficiency is too low.

2. Convert to 01 backpack
replacing the i-I Item into the article in the N [I] piece 01 backpack, which converts the 01 backpack problem of σn [i], and the complexity is still O (V * ΣN [I]).
The code is as follows:

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn = 100+10;
const int max_n = 1000000;
int w[maxn], v[maxn], a[maxn];
int w_n[max_n], v_n[max_n];
int dp[max_n];
int N, W;
int k; 
/ * 01 backpack * /
void solve()
{
    for(int i=0; i<k; i++)
    {
        for(int j=W; j>=w_n[i]; j--)
        {
            dp[j] = max(dp[j], dp[j-w_n[i]]+v_n[i]);    
        }   
    }
    printf("%d\n",dp[W]);
}

int main()
{
    scanf("%d%d",&N,&W);
    k=0;
    for(int i=0; i<N; i++)
    {
        scanf("%d%d%d",&w[i],&v[i],&a[i]);
        // convert the first item to N [i] piece 01 item
        for(int j=0; j<a[i]; j++)
        {
            w_n[k] = w[i];
            v_n[k] = v[i];
            k++;
        }
    }
    solve();
    return 0;
}

Optimal algorithm：

The first item is divided into a plurality of items, wherein each item has a coefficient, the weight and value of this item is the original weight and value multiplication by this coefficient. Make these coefficients of 1, 2, 4, ..., 2 ^ (k-1), n ​​[i] -2 ^ k + 1, and K is satisfying N [I] -2 ^ k + 1> 0 Integer. For example, if N [i] is 13, the division of this article is 1, 2, 4, 6, respectively, of 1, 2, 4, 6, respectively.
This is divided into O (LOG N [I]) items, converting the original problem to complexity O (V * σlog n [i]) 01 Backpack problem.
- from "Backpack Nine Speaking"

This isBinarylaw.

code show as below:

#include<cstdio>
#include<algorithm>
using namespace std;

const int maxn = 100+10;
int N,W; 
int w[maxn], v[maxn], a[maxn]; 
int dp[maxn];
/ * 01 backpack * /
void zero_pack(int w, int v)
{
    for(int j=W; j>=w; j--)
    {
        dp[j] = max(dp[j], dp[j-w]+v);
    }
}
/ * Complete backpack * /
void comp_pack(int w, int v)
{
    for(int j=w; j<=W; j++)
    {
        dp[j] = max(dp[j], dp[j-w]+v);
    }
}
/ * Multiple backpacks * /
void mult_pack(int w, int v, int a)
{
    // If the number of items is multiplied by weight is greater than or equal to W, then the optimal solution of this item is directly pushed directly with a complete backpack.
    if(w * a >= W)
    {
        comp_pack(w, v);
        return;
    }
    int k = 1;
    while(k < a)
    {
        zero_pack(k*w, k*v);
        a = a - k;
        k = k*2;
    }
    // Remaining another 01 backpack
    zero_pack(a*w, a*v);
}

int main()
{
    scanf("%d%d",&N, &W);
    for(int i=0; i<N; i++)
    {
        scanf("%d%d%d",&w[i],&v[i],&a[i]);  
    } 
    for(int i=0; i<N; i++)
    {
        mult_pack(w[i], v[i], a[i]);
    }
    printf("%d\n",dp[W]);
    return 0;
}