完全背包

                 （1）未压缩空间

                      1.问题描述

                         有N种物品和一个容量为V的背包，每种物品都有无限件可以使用，第i件物品的重量为weight[i]，价值为value[i]。求解将哪些物品放入背包可使总价值最大。

                      2.特点

                        每种物品有无数件

                     3.分析

                         定义dp[i][j]：表示前i件物品放入容量为j的背包中可获得的最大价值。

                         对于第i件物品，有放0件、1件。。。，k种选择，只要保证k*weight[i]<=v即可。如果不放，那么dp[i][j]=dp[i-1][j]，即等于前i-1件物品放入容量为j的背包所获得的最大价值；如果放入，那么dp[i][j]=dp[i-1][j-k*weight[i]+k*value[i]]，即等于前i-1件物品放入容量为j-k*weight[i]的背包中，再加上k件第i件物品的总价值k*value[i]

                        状态转移方程为：dp[i][j] = max{dp[i-1][j]，dp[i-1][j-k*weight[i]]+k*value[i]}   其中k*weight[i]<v

                     4.代码

		int[][] dp = new int[4][11];
		int[] weight = {3,4,5};
		int[] value = {4,5,6};
		
		for(int i=1; i<4; i++)
		{
			for(int j=1; j<11; j++)
			{
				int max = -1;
				for(int k=0; k*weight[i-1]<=j; k++)
				{
					max = Math.max(max, dp[i-1][j-k*weight[i-1]]+k*value[i-1]);
				}
				dp[i][j] = max;
			}
		}
		System.out.println(dp[3][10]);

                 （2）压缩空间

                      1.思路

                         和0-1背包一样，完全背包也可以使用一维数组来记录最大值，只是二重循环需要正序

                         状态转移方程为：dp[j] = max{dp[j]，dp[j-weight[i]]+value[i]}，weight[i]<=j

                      2.代码

		int n = 3;
		int v = 10;
		int[] weight = {3,4,5};
		int[] value = {4,5,6};
		
		int[] dp = new int[v+1];
		
		for(int i=1; i<=n; i++)
		{
			for(int j=1; j<=v; j++)
			{
				if(j-weight[i-1] >= 0)
				{
					if(dp[j]<value[i-1]+dp[j-weight[i-1]])
						dp[j] = value[i-1]+dp[j-weight[i-1]];
					else
						dp[j] = dp[j];
				}
				else
					dp[j] = dp[j];
			}
		}
		System.out.println(dp[v]);

                 （3）背包所含物品

                      1.思路

                          可以使用一个二维数组path[n][v]，path[i][j]用来记录容量为j的背包是否选择了第i件物品，1表示选择，0表示不选，初始化时全为0

                          结束时，可以判断path[i][j]是否=1，如果=1，说明选择了第i件物品，然后容量j = j-weight[i]；否则=0，说明没有选择第i件物品，直接i--即可。

                       2.代码

		int n = 3;
		int v = 10;
		int[] weight = {3,4,5};
		int[] value = {4,5,6};
		
		int[] dp = new int[v+1];
		int[][] path = new int[n+1][v+1];
		
		for(int i=1; i<=n; i++)
		{
			for(int j=1; j<=v; j++)
			{
				if(j-weight[i-1] >= 0)
				{
					if(dp[j]<value[i-1]+dp[j-weight[i-1]])
					{
						dp[j] = value[i-1]+dp[j-weight[i-1]];
						path[i][j] = 1;
					}
					else
						dp[j] = dp[j];
				}
				else
					dp[j] = dp[j];
			}
		}
		System.out.println(dp[v]);
		
		int i = n; 
		int j = v;
		while(i>0 && j>0)
		{
			if(path[i][j] == 1)
			{
				System.out.print(value[i-1]+" ");
				j = j - weight[i-1];
			}
			else
				i--;
		}

                结果为：

13
5 4 4 

                 （4）求最大值方案的数量

                      1.思路

                          和0-1背包完全相同

                       2.代码

		int n = 4;
		int v = 10;
		
		int[] weight = {3,4,5,10};
		int[] value = {4,5,6,13};
		
		int[] dp = new int[v+1];
		int[] plan = new int[v+1];
		for(int i=0; i<=v; i++)
			plan[i] = 1;
		
		for(int i=1; i<=n; i++)
		{
			for(int j=1; j<=v; j++)
			{
				if(j>=weight[i-1])
				{
					if(dp[j]<dp[j-weight[i-1]]+value[i-1])
					{
						dp[j] = dp[j-weight[i-1]]+value[i-1];
						plan[j] = plan[j-weight[i-1]];
					}
					else if(dp[j] == dp[j-weight[i-1]]+value[i-1])
					{
						plan[j] = plan[j]+plan[j-weight[i-1]];
						dp[j] = dp[j];
					}
					else
						plan[j] = plan[j];
				}
			}
		}
		System.out.println(dp[v]);
		System.out.println(plan[v]);

                 （5）求恰好装满的方案的数量

                      1.思路

                          和0-1背包完全相同

                       2.代码

		int n = 3;
		int v = 10;
		
		int[] weight = {3,4,5};
		int[] value = {4,5,6};
		
		int[] plan = new int[v+1];
		plan[0] = 1;
		
		for(int i=1; i<=n; i++)
		{
			for(int j=1; j<=v; j++)
			{
				if(j>=weight[i-1])
					plan[j] = plan[j]+plan[j-weight[i-1]];
			}
		}
		for(int i=0 ;i<=v; i++)
		System.out.print(plan[i]+" ");