几道比较简单动态规划（DP）之背包

动态规划（Dynamic Programming，简称DP），动态规划(dynamic programming)是运筹学的一个分支，是求解决策过程(decision process)最优化的数学方法。一般是把一个大问题分成很多个子问题来求最优解。

背包问题也是动态规划一种常见的问题，01背包问题是基础。

GDUFE OJ1131 1132 1133

                                                        背包1

Time Limit: 2000/1000ms (Java/Others)

Problem Description:

   有 n 个重量和价值分别为Wi,Vi的物品，现从这些物品中挑选出总量不超过 W 的物品，求所有方案中价值总和的最大值。

Input:

输入包含多组测试用例，每一例的开头为两位整数 n、W（1<=n<=10000,1<=W<=1000）
，接下来有 n 行，每一行有两位整数 Wi、Vi（1<=Wi<=10000,1<=Vi<=100）。

Output:

输出为一行，即所有方案中价值总和的最大值。

Sample Input:

3 4
1 2
2 5
3 7

Sample Output:

9

Source:

hhh

题解：每次取和不取（01背包问题）都和之前的比较，取最优的取法。

import java.util.Arrays;
import java.util.Scanner;

public class Main {
	static Scanner scan = new Scanner(System.in);
	static int[] v = new int[10001];
	static int[] w = new int[10001];
	static int[] dp = new int[10001];
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		while(scan.hasNext()){
			int n = scan.nextInt();
			int W = scan.nextInt();
			v = new int[n+1];
			w = new int[n+1];
			for(int i=1;i<=n;i++){
				w[i] = scan.nextInt();
				v[i] = scan.nextInt();
			}
			for(int i = 1; i <= n; i++)
	                    for(int j = W; j >= 0; j--){      //每次更新容量为j，所能放下最大价值的物品
	                        if(j >= w[i]){        //j一定要大于w[i],要不最大容量为j的背包放不下第i件物品
	                            dp[j] = Math.max(dp[j], dp[j-w[i]] + v[i]);    //dp[j] 表示最大容量为j的背包所装下物品最大的价值，         这里求的是第i件物品放和不放的价值的最大的价值
	                    }
	                }
			System.out.println(dp[W]);
	       	}
	}
}

 

                                                           背包2

Time Limit: 2000/1000ms (Java/Others)

Problem Description:

 有 n 个重量和价值分别为Wi,Vi的物品，现从这些物品中挑选出总量刚好为 W 的物品，求所有方案中价值总和的最大值。

Input:

输入包含多组测试用例，每一例的开头为两位整数 n、W（1<=n<=10000,1<=W<=1000），接下来有 n 行，每一行有两位整数 Wi、Vi（1<=Wi<=10000,1<=Vi<=100）。

Output:

输出为一行，即所有方案中价值总和的最大值。若不存在刚好填满的情况，输出“-1”。

Sample Input:

3 4
1 2
2 5
2 1
3 4
1 2
2 5
5 1

Sample Output:

6
-1

Source:

hhh

题解：因为这里的背包是刚好是装这个重量，所以我在这里设了一个标记数组text[ ],当text[ k ]等于1时，表示对应的背包能刚好装k重量的物品。注意text[]初始化时，text[0] = 1,因为背包能刚好装下重量为0的物品。

import java.util.Arrays;
import java.util.Scanner;

public class Main {
	static Scanner scan = new Scanner(System.in);
	static int[] v = new int[10005];
	static int[] w = new int[10005];
	static int[] dp = new int[10005];
	static int[] text = new int[10005];     
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		while(scan.hasNext()){
			int n = scan.nextInt();
			int W = scan.nextInt();
			v = new int[n+1];
			w = new int[n+1];
			for(int i=1;i<=n;i++){
				w[i] = scan.nextInt();
				v[i] = scan.nextInt();
			}
			Arrays.fill(dp, 0);
			Arrays.fill(text, 0);       //text为标记数组,标记现在的背包是否能放下刚好是这重量的物品
			text[0] = 1; 
			for(int i=1;i<=n;i++)
				for(int j=W;j>=0;j--){     //因为物品的数量只有一个，所以要从后面开始遍历
					if(j>=w[i]&&text[j-w[i]]==1){     //搜索能重叠的，进行赋值
						dp[j] = Math.max(dp[j], dp[j-w[i]] + v[i]);     //dp[j]（放的物品重量恰好为j）表示当前数量的最大的价值。
						text[j] = 1;
					}
				}
			if(dp[W]==0)
				System.out.println(-1);
			else
				System.out.println(dp[W]);			
		}
	}
}

 

                                                         背包3

Time Limit: 2000/1000ms (Java/Others)

Problem Description:

  有 n 种（每一种有无数个）重量和价值分别为Wi,Vi的物品，现从这些物品中挑选出总量不超过 W 的物品，求所有方案中价值总和的最大值。

Input:

输入包含多组测试用例，每一例的开头为两位整数 n、W（1<=n<=10000,1<=W<=1000）

，接下来有 n 行，每一行有两位整数 Wi、Vi（1<=Wi<=10000,1<=Vi<=100）

 

Output:

输出为一行，即所有方案中价值总和的最大值。

Sample Input:

3 4
1 2
2 5
3 7
3 5
2 3
3 4
4 5

Sample Output:

10
7

Source:

hhh

题解：因为物品是无限的，所以要从0开始遍历，dp[ j ]放（小于等于）j重量的最大的价值。

import java.util.Arrays;
import java.util.Scanner;

public class Main {
	static Scanner scan = new Scanner(System.in);
	static int[] v = new int[10005];
	static int[] w = new int[10005];
	static int[] dp = new int[10005];
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		while(scan.hasNext()){
			int n = scan.nextInt();
			int W = scan.nextInt();
			v = new int[n+1];
			w = new int[n+1];
			for(int i=1;i<=n;i++){
				w[i] = scan.nextInt();
				v[i] = scan.nextInt();
			}
			Arrays.fill(dp, 0);
			for(int i = 1; i <= n; i++)
	            for(int j = 0; j <=W; j++){       //因为物品是无限的，所以要从0开始遍历，dp[j]放（小于等于）j重量的最大的价值 
	                if(j >= w[i]){
	                    dp[j] = Math.max(dp[j], dp[j-w[i]] + v[i]);    
	                }
	            }
			System.out.println(dp[W]);
		}
	}
}

Gdufe_2018_Summer IV (B)

                                                         饭卡

电子科大本部食堂的饭卡有一种很诡异的设计，即在购买之前判断余额。如果购买一个商品之前，卡上的剩余金额大于或等于5元，就一定可以购买成功（即使购买后卡上余额为负），否则无法购买（即使金额足够）。所以大家都希望尽量使卡上的余额最少。
某天，食堂中有n种菜出售，每种菜可购买一次。已知每种菜的价格以及卡上的余额，问最少可使卡上的余额为多少。

Input

多组数据。对于每组数据：
第一行为正整数n，表示菜的数量。n<=1000。
第二行包括n个正整数，表示每种菜的价格。价格不超过50。
第三行包括一个正整数m，表示卡上的余额。m<=1000。

n=0表示数据结束。

Output

对于每组输入,输出一行,包含一个整数，表示卡上可能的最小余额。

Sample Input

1
50
5
10
1 2 3 2 1 1 2 3 2 1
50
0

Sample Output

-45
32

题解：还算比较裸的DP问题。我用一个数组，dp[ ]标记经过各种可能点菜的情况（不能点最高价格的菜，因为最后才点它）之后剩余的钱，有这个情况，标志为1。然后得出大于等于5块钱的最低剩余的钱。然后再用这个剩余的钱减去最高价格的菜的钱。

import java.util.Arrays;
import java.util.Scanner;

public class Main {
	static Scanner scan = new Scanner(System.in);
	static int[] dp = new int[1005];
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		while(scan.hasNext()){
			int n = scan.nextInt();
			if(n==0)
				break;
			int[] arr = new int[n+1];
			for(int i=1;i<=n;i++){
				arr[i] = scan.nextInt();
			}
			int min = scan.nextInt();
			if(min < 5)
			{
				System.out.println(min);
			}
			else{
				Arrays.sort(arr);
				int arrmax = arr[arr.length-1];
			
				Arrays.fill(dp, 0);
			
			
				dp[min]++;
			
				for(int i=1;i<n;i++)
					for(int j=5;j<=min;j++){
						if(j-arr[i]>=5&&dp[j]==1){
							dp[j-arr[i]] = 1;
						}
					}
				for(int i=5;i<=min;i++){
					if(dp[i]==1){
						min = i;
						break;
					}
				}
				
				int ans = min-arrmax;
				System.out.println(ans);
			}
		}
	}

}