Multiple backpack

 There is a backpack with a total volume of V, there are n items, and the volume is $v_i$vi​, The value is $w_i$wi​, The quantity is $c_i$ci​, How to get the maximum volume
There are three solutions to the multiple knapsack problem: 1. Convert to 01 knapsack 2. Binary decomposition 3. Monotonic queue optimization, generally using binary decomposition.
1. Converting to a 01 backpack is similar to the conversion of a full backpack to a 01 backpack. We have talked about it before.

const int n=1010;
int dp[n];
int Multiple_pack(vector<int>&v, vector<int>&w,vector<int> c, int V)
{
  dp[0]=0;
  for(int i=0;i<v.size();i++)
  {
    for(int j=V;j>=v[i];j++)
    {
      for(int k=0;k<=c[i]&&k<=j/v[i],k++)
      {
        dp[j]=max(dp[j],dp[j-K*v[i]]+k*w[i]);
      }
    }
  }
  return dp[V];
}

The time complexity is $O(nVK)$O(nVK), The space complexity is $O(V)$O(V)
 2, binary decomposition can optimize the time complexity, the optimization is $O(nVlog(c))$O(nVlog(c)). The principle of binary decomposition is to use a series of binary numbers or add a number to represent a specified number.
For example, 12 can be represented by (1 2 4 5)
$1\rightarrow1,2\rightarrow2,1+2\rightarrow3,4\rightarrow4,1+4\rightarrow5,1+5\rightarrow6,2+5\rightarrow7,1+2+5\rightarrow8$1→1,2→2,1+2→3,4→4,1+4→5,1+5→6,2+5→7,1+2+5→8
$4+5\rightarrow9,1+4+5\rightarrow10,2+4+5\rightarrow11,1+2+4+5\rightarrow12$4+5→9,1+4+5→10,2+4+5→11,1+2+4+5→12
 So through a series of binary numbers, the optimization of multiple knapsacks can be realized.

const int n=1010;
int dp[n];
//Because multiple backpacks will call 01 backpack, we first give 01 backpack, the function of complete backpack
void Zero_one_pack(int v_i, int w_i,int V) 
{
   for(int i=V;i>=v[i];i--)
      {
        dp[i]=max(dp[i],dp[i-v[i]]+w[i]);
      }  
}
void Complete_pack(int v_i, int w_i,int V) 
{
   for(int i=v[i];i<=V;i++)
      {
        dp[i]=max(dp[i],dp[i-v[i]]+w[i]);
      }  
}
int Op1_Multiple_pack(vector<int>&v, vector<int>&w,vector<int> c, int V)
{
  dp[0]=0;
  for(int i=0;i<v.size();i++)
  {
  //When the number of c[i] is greater than or equal to the maximum number allowed, go directly to the complete backpack
    if(V/v[i]<=c[i])
    {
      Complete_pack(v[i], w[i],V);
      continue;
    }
     //Otherwise, perform binary optimization
    for(int j=1;j<=c[i];j*=2)
    {
    // 01 backpack equivalent to it
        c[i]-=j;
       Zero_one_pack(j*v[i],j*w[i],V);
    }
     //There may be a number that is not binary, such as 5 in our example, continue with 01 backpack
       Zero_one_pack(c[i]*v[i],c[i]*w[i],V);
  }
      return dp[V];
}

Time is complicated $O(nVlog(c))$O(nVlog(c))

Hybrid backpack

 There is a backpack with a total volume of V, there are n items, and the volume is $v_i$vi​, The value is $w_i$wi​, The quantity is divided into three types,
  $-1$−1Means only 1 (01 backpack)
  $0$0Indicates that the number is unlimited (complete backpack)
  $c_i$ci​Means there is $c_i$ci​Quantity (multiple backpacks)
 The method is to discuss it separately. According to our previous approach, the multiple knapsack problem and 01 knapsack problem are done according to the 01 knapsack solution, and the complete knapsack is done according to the complete knapsack solution.

int v=1010;
int dp[n];
void Zero_one_pack(int v_i, int w_i,int V) 
{
   for(int i=V;i>=v[i];i--)
      {
        dp[i]=max(dp[i],dp[i-v[i]]+w[i]);
      }  
}
void Complete_pack(int v_i, int w_i,int V) 
{
   for(int i=v[i];i<=V;i++)
      {
        dp[i]=max(dp[i],dp[i-v[i]]+w[i]);
      }  
}
int Op1_Multiple_pack(vector<int>&v, vector<int>&w,vector<int> c, int V)
{
  for(int i=0;i<v.size(); i++)
  {
      if(c[i]==0)
      {
         //Completely backpack
         Complete_pack(v[i],w[i],V);
      }
      else if(c[i]==-1)
      {
         //01 backpack
         Zero_one_pack(v[i],w[i],V);
      }
      else
      {
        //The binary decomposition of the multiple knapsack problem is doing 01 knapsack
         for(int j=1;j<=c[i];j*=2)
          {
            c[i]-=j;
            Zero_one_pack(j*v[i],j*w[i],V);
          }
     //It is possible that there is still a number that is not binary, continue with the 01 backpack
            Zero_one_pack(c[i]*v[i],c[i]*w[i],V);
       }  
  }
  return dp[V];
}