题单简介
动态规划是一种重要的思维方法，通过利用已有的子问题信息高效求出当前问题的最优解。
疯狂的采药
题目背景
此题为纪念 LiYuxiang 而生。
题目描述
LiYuxiang 是个天资聪颖的孩子，他的梦想是成为世界上最伟大的医师。为此，他想拜附近最有威望的医师为师。医师为了判断他的资质，给他出了一个难题。医师把他带到一个到处都是草药的山洞里对他说：“孩子，这个山洞里有一些不同种类的草药，采每一种都需要一些时间，每一种也有它自身的价值。我会给你一段时间，在这段时间里，你可以采到一些草药。如果你是一个聪明的孩子，你应该可以让采到的草药的总价值最大。”
如果你是 LiYuxiang，你能完成这个任务吗？
此题和原题的不同点：
-
每种草药可以无限制地疯狂采摘。
-
药的种类眼花缭乱，采药时间好长好长啊！师傅等得菊花都谢了！
输入格式
输入第一行有两个整数，分别代表总共能够用来采药的时间 t 和代表山洞里的草药的数目 m。
第 2 到第 (m+1) 行，每行两个整数，第 (i+1) 行的整数 ai ,bi分别表示采摘第 i 种草药的时间和该草药的价值。
输出格式
输出一行，这一行只包含一个整数，表示在规定的时间内，可以采到的草药的最大总价值。
输入输出样例
输入 #1复制
70 3
71 100
69 1
1 2
输出 #1复制
140
思路：完全背包模板题。我们可以对他进行空间上的压缩。
import java.util.Scanner;
public class Main{
static int n,m,r,c;
static int[] dp = new int[10100000];
static int[] book = new int[25];
static int[][] arr = new int[25][25];
static int[][] next = {{-1,0},{0,1},{1,0},{0,-1}};
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
m = sc.nextInt(); //背包的容量
n = sc.nextInt();//物品的数量
for(int i=0;i<n;i++){
int a = sc.nextInt(); //时间
int b = sc.nextInt();//价值
for(int j=a;j<=m;j++){
dp[j] = Math.max(dp[j],dp[j-a]+b);
}
}
System.out.print(dp[m]);
}
}
采药
题目描述
辰辰是个天资聪颖的孩子，他的梦想是成为世界上最伟大的医师。为此，他想拜附近最有威望的医师为师。医师为了判断他的资质，给他出了一个难题。医师把他带到一个到处都是草药的山洞里对他说：“孩子，这个山洞里有一些不同的草药，采每一株都需要一些时间，每一株也有它自身的价值。我会给你一段时间，在这段时间里，你可以采到一些草药。如果你是一个聪明的孩子，你应该可以让采到的草药的总价值最大。”
如果你是辰辰，你能完成这个任务吗？
输入格式
第一行有 2 个整数 T（1≤T≤1000）和 M（1≤M≤100），用一个空格隔开，T 代表总共能够用来采药的时间，M 代表山洞里的草药的数目。
接下来的 M 行每行包括两个在 1 到 100 之间（包括 1 和 100）的整数，分别表示采摘某株草药的时间和这株草药的价值。
输出格式
输出在规定的时间内可以采到的草药的最大总价值。
输入输出样例
输入 #1复制
70 3
71 100
69 1
1 2
输出 #1复制
3
思路：01背包模板题。我们在空间上对其进行了优化。
import java.util.Scanner;
public class Main{
static int n,m,r,c;
static int[] dp = new int[1010];
static int[] book = new int[25];
static int[][] arr = new int[25][25];
static int[][] next = {{-1,0},{0,1},{1,0},{0,-1}};
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
m = sc.nextInt(); //背包的容量
n = sc.nextInt();//物品的数量
for(int i=0;i<n;i++){
int a = sc.nextInt(); //时间
int b = sc.nextInt();//价值
for(int j=m;j>=a;j--){
dp[j] = Math.max(dp[j],dp[j-a]+b);
}
}
System.out.print(dp[m]);
}
}
挖地雷
题目描述
在一个地图上有N个地窖(N≤20)，每个地窖中埋有一定数量的地雷。同时，给出地窖之间的连接路径。当地窖及其连接的数据给出之后，某人可以从任一处开始挖地雷，然后可以沿着指出的连接往下挖（仅能选择一条路径），当无连接时挖地雷工作结束。设计一个挖地雷的方案，使某人能挖到最多的地雷。
输入格式
有若干行。
第1行只有一个数字，表示地窖的个数N。
第2行有N个数，分别表示每个地窖中的地雷个数。
第3行至第N+1行表示地窖之间的连接情况：
第3行有n−1个数（0或1），表示第一个地窖至第2个、第3个、…、第n个地窖有否路径连接。如第3行为1 1 0 0 0 … 0则表示第1个地窖至第2个地窖有路径，至第3个地窖有路径，至第4个地窖、第5个、…、第n个地窖没有路径。
第4行有n−2个数，表示第二个地窖至第3个、第4个、…、第n个地窖有否路径连接。
… …
第n+1行有1个数，表示第n−1个地窖至第n个地窖有否路径连接。（为0表示没有路径，为1表示有路径）。
输出格式
有两行
第一行表示挖得最多地雷时的挖地雷的顺序，各地窖序号间以一个空格分隔，不得有多余的空格。
第二行只有一个数，表示能挖到的最多地雷数。
输入输出样例
输入 #1复制
5
10 8 4 7 6
1 1 1 0
0 0 0
1 1
1
输出 #1复制
1 3 4 5
27
思路：由题意可以知道，i号地窖只能挖j号及其以后的地窖（j>i）。我们可以从后向前循环，每个地窖在能到达的地窖中选择一个最优解。维护一个最大值。
import java.util.Scanner;
public class Main{
static int n,r,c;
static int[] count = new int[25];
static int[] book = new int[25];
static int[][] arr = new int[25][25];
static int[][] next = {{-1,0},{0,1},{1,0},{0,-1}};
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
for(int i=1;i<=n;i++){
count[i] = sc.nextInt();
}
for(int i=1;i<n;i++){
for(int j=i+1;j<=n;j++){
arr[i][j] = sc.nextInt();
}
}
int ans = 0;
int frist = 0;
for(int i=n-1;i>=1;i--){
int max = 0;
for(int j=i+1;j<=n;j++){
if(arr[i][j]==1){
if(max<count[j]){
book[i] = j;
max = Math.max(max,count[j]);
}
}
}
count[i] += max;
if(ans<count[i]){
frist = i;
ans = Math.max(count[i],ans);
}
}
System.out.print(frist);
frist = book[frist];
while(frist!=0){
System.out.print(" "+frist);
frist = book[frist];
}
System.out.println("
"+ans);
}
}
5倍经验日
题目背景
现在乐斗有活动了！每打一个人可以获得5倍经验！absi2011却无奈的看着那一些比他等级高的好友，想着能否把他们干掉。干掉能拿不少经验的。
题目描述
现在absi2011拿出了x个迷你装药物(嗑药打人可耻….)，准备开始与那些人打了
由于迷你装一个只能管一次，所以absi2011要谨慎的使用这些药，悲剧的是，没到达最少打败该人所用的属性药了他打人必输>.<所以他用2个药去打别人，别人却表明3个药才能打过，那么相当于你输了并且这两个属性药浪费了。
现在有n个好友，有输掉拿的经验、赢了拿的经验、要嗑几个药才能打过。求出最大经验（注意，最后要乘以5）
输入格式
第一行两个数，n和x
后面n行每行三个数，分别表示输了拿到的经验(lose[i])、赢了拿到的经验(win[i])、打过要至少使用的药数量(use[i])。
输出格式
一个整数，最多获得的经验
输入输出样例
输入 #1复制
6 8
21 52 1
21 70 5
21 48 2
14 38 3
14 36 1
14 36 2
输出 #1复制
1060
思路：01背包的变形题，注意在不取当前物品时依然要加一个经验，不取包括不取和取不到的时候。
import java.util.Scanner;
public class Main{
static int n,m;
static long[] dp = new long[1010];
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
n = sc.nextInt(); //物品的数量
m = sc.nextInt();//背包容量
for(int i=0;i<n;i++){
int b1 = sc.nextInt(); //不拿的价值
int b2 = sc.nextInt();//拿的价值
int a = sc.nextInt(); //体积
for(int j=m;j>=a;j--){
dp[j] = Math.max(dp[j]+b1,dp[j-a]+b2);
}
for(int j =a-1;j>=0;j--){
dp[j] +=b1;
}
}
System.out.print(dp[m]*5);
}
}
过河卒
题目描述
棋盘上 A 点有一个过河卒，需要走到目标 B 点。卒行走的规则：可以向下、或者向右。同时在棋盘上 C 点有一个对方的马，该马所在的点和所有跳跃一步可达的点称为对方马的控制点。因此称之为“马拦过河卒”。
棋盘用坐标表示，A 点 (0, 0)、B 点(n,m)，同样马的位置坐标是需要给出的。
现在要求你计算出卒从 A 点能够到达 B 点的路径的条数，假设马的位置是固定不动的，并不是卒走一步马走一步。
输入格式
一行四个正整数，分别表示 BB 点坐标和马的坐标。
输出格式
一个整数，表示所有的路径条数。
输入输出样例
输入 #1复制
6 6 3 3
输出 #1复制
6
思路：记忆化搜索。
import java.util.Scanner;
public class Main{
static int x0,y0,x1,y1;
static long[][] count = new long[22][22],next ={{-1,-2},{-2,-1},{-2,1},{-1,2},{1,-2},{2,1},{2,-1},{1,2}};
static boolean[][] flag = new boolean[22][22];
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
x1 = sc.nextInt();
y1 = sc.nextInt();
x0 = sc.nextInt();
y0 = sc.nextInt();
count[x1][y1] = 1;
flag[x1][y1] = true;
dfs(0,0);
System.out.print(count[0][0]);
}
public static long dfs(int x,int y){
if(flag[x][y]){ //表示该点已经标记过
return count[x][y];
}
int tx ;
int ty;
tx = x;
ty = y+1;
if(tx>=0&&tx<=x1&&ty>=0&&ty<=y1&&ok(tx,ty)) count[x][y] += dfs(tx,ty);
tx = x+1;
ty = y;
if(tx>=0&&tx<=x1&&ty>=0&&ty<=y1&&ok(tx,ty)) count[x][y] += dfs(tx,ty);
flag[x][y] = true;
return count[x][y];
}
public static boolean ok(int x,int y){ //是否是马能到的点
if(x==x0&&y==y0) return false;
long tx ;
long ty;
for(int i=0;i<8;i++){
tx = x0+next[i][0];
ty = y0+next[i][1];
if(x==tx&&y==ty){
return false;
}
}
return true;
}
}
[SHOI2002]滑雪
题目描述
Michael 喜欢滑雪。这并不奇怪，因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael 想知道在一个区域中最长的滑坡。区域由一个二维数组给出。数组的每个数字代表点的高度。下面是一个例子：
1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9
一个人可以从某个点滑向上下左右相邻四个点之一，当且仅当高度会减小。在上面的例子中，一条可行的滑坡为 24－17－16－1（从 24 开始，在 1 结束）。当然 25－24－23－－3－2－1 更长。事实上，这是最长的一条。
输入格式
输入的第一行为表示区域的二维数组的行数 R 和列数 C。下面是 R 行，每行有 C 个数，代表高度(两个数字之间用 1 个空格间隔)。
输出格式
输出区域中最长滑坡的长度。
输入输出样例
输入 #1复制
5 5
1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9
输出 #1复制
25
思路：记忆化搜索。
import java.util.Scanner;
public class Main{
static int r,c;
static int[][] count = new int[105][105];
static int[][] arr = new int[105][105];
static int[][] next = {{-1,0},{0,1},{1,0},{0,-1}};
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
r = sc.nextInt();
c = sc.nextInt();
for(int i=1;i<=r;i++){
for(int j=1;j<=c;j++){
arr[i][j] = sc.nextInt();
}
}
int ans = 0;
for(int i=1;i<=r;i++){
for(int j=1;j<=c;j++){
dfs(i,j);
ans = Math.max(ans,count[i][j]);
}
}
System.out.println(ans);
}
public static int dfs(int x,int y){
if(count[x][y]!=0) return count[x][y]; //已经找过这条路了 直接返回长度
count[x][y] = 1;
int max = 0;
for(int i=0;i<4;i++){
int tx = x+next[i][0];
int ty = y+next[i][1];
if(tx>=1&&tx<=r&&ty>=1&&ty<=c&&arr[tx][ty]<arr[x][y]){
max = Math.max(dfs(tx,ty),max);
}
}
count[x][y]+=max;
return count[x][y];
}
}
数字金子塔
题目描述
观察下面的数字金字塔。
写一个程序来查找从最高点到底部任意处结束的路径，使路径经过数字的和最大。每一步可以走到左下方的点也可以到达右下方的点。
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
在上面的样例中,从7→3→8→7→5 的路径产生了最大
输入格式
第一个行一个正整数 r ,表示行的数目。
后面每行为这个数字金字塔特定行包含的整数。
输出格式
单独的一行,包含那个可能得到的最大的和。
输入输出样例
输入 #1复制
5
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
输出 #1复制
30
思路：经典的dp模型，从下向上做会简单一些。
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int r = sc.nextInt();
int[][] arr = new int[1005][1005];
for(int i=1;i<=r;i++){
for(int j=1;j<=i;j++){
arr[i][j] = sc.nextInt();
}
}
for(int i=r;i>=1;i--){
for(int j=1;j<=i;j++){
arr[i][j] = Math.max(arr[i+1][j],arr[i+1][j+1])+arr[i][j];
}
}
System.out.println(arr[1][1]);
}
}