洛谷题单 【动态规划1】动态规划的引入

题单简介
动态规划是一种重要的思维方法，通过利用已有的子问题信息高效求出当前问题的最优解。

疯狂的采药

题目背景
此题为纪念 LiYuxiang 而生。

题目描述
LiYuxiang 是个天资聪颖的孩子，他的梦想是成为世界上最伟大的医师。为此，他想拜附近最有威望的医师为师。医师为了判断他的资质，给他出了一个难题。医师把他带到一个到处都是草药的山洞里对他说：“孩子，这个山洞里有一些不同种类的草药，采每一种都需要一些时间，每一种也有它自身的价值。我会给你一段时间，在这段时间里，你可以采到一些草药。如果你是一个聪明的孩子，你应该可以让采到的草药的总价值最大。”

如果你是 LiYuxiang，你能完成这个任务吗？

此题和原题的不同点：

1. 每种草药可以无限制地疯狂采摘。

2. 药的种类眼花缭乱，采药时间好长好长啊！师傅等得菊花都谢了！

输入格式
输入第一行有两个整数，分别代表总共能够用来采药的时间 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]);
    }
}