Multiple backpacks, the number of items that can be selected is limited, up to c[i]

1. Binary optimization:

The idea of ​​binary optimization is still very clever, according to c [i] to get a set of such numbers 2^0,2^1,2^2,2^3.....2^(k-1) , c-2^k+1Where k is the maximum value that satisfies 2^k less than c, like c=7=111, 2^k=100=4;

 c=9=1001, 2^k=1000=8  ;  c=8=1000  2^k=0100=4   

What is the purpose of getting this set of numbers,

All numbers between 1 and c can be obtained from this group of numbers (choose to add), and any number from this group of numbers (each number can only be selected once) must be added together. Is in the closed interval of 1~c

For example, 14=1110 The corresponding set of numbers is: 1, 2, 4, 7 You can try it. Through the first three combinations, you can get all the numbers between 1~7, and add 7 to get 8~14 All the numbers in between, so we can get any number between 1~14, so we can only backpack this group of numbers one by one, instead of backpacking 01 from 1 to c, it is O(c) Partially optimized to O (logc)

void erjinzhi()
{
	int i,j,k,m;
	memset(dp,0,sizeof(dp));
	for(i=0;i<n;i++)
	{
		for(k=1;k<<1<c[i];k<<=1)
		{
			for(j=V;j>=k*v[i];j--)
			{
				dp[j]=max(dp[j],dp[j-k*v[i]]+k*w[i]);
			}
		}
		m=c[i]-k+1;
		for(j=V;j>=m*v[i];j--)
		{
			dp[j]=max(dp[j],dp[j-m*v[i]]+m*w[i]);
		}
	} 
}

2. Monotonic queue optimization

Refer to the ideas of this blog http://blog.csdn.net/flyinghearts/article/details/5898183 and the code of Lord K http://blog.csdn.net/lxy767087094/article/details/54730613, plus myself Understanding

The general idea of ​​that blog is very good. The implementation process uses two queues, one auxiliary queue, which is not easy to understand

struct node
{
	int num,value;
}que[100000];
int tail,head;
void push(int x,int y)
{
	while(tail>head&&que[tail-1].value<y)
	{
		tail--;
	}
	que[tail].num=x;
	que[tail++].value=y;
}
void singlequeue()
{
	int i,d,j;
	memset(dp,0,sizeof(dp));
	for(i=0;i<n;i++)
	{
		c[i]=min(c[i],V/v[i]);
		for(d=0;d<v[i];d++)
		{
			head=tail=0;
			for(j=0;j<=(V-d)/v[i];j++)
			{
				push(j,dp[j*v[i]+d]-j*w[i]);
				while(que[head].num<j-c[i]&&tail>head)
				head++;
				dp[j*v[i]+d]=que[head].value+j*w[i];
			}
		}
	}
}

Original blog site: http://blog.csdn.net/jerans/article/details/54916955