WenJieWangFlyToWorld

导航

动态规划常见题型

找零钱

 题目： 给定数组arr，arr中所有的值都为整数且不重复。每个值代表一种面值的货币，每种面值的货币可以使用任意张，再你给定一个整数aim代表要找的钱数，求 换钱有多少种方法

暴力搜索方法

解题思路：

概率论知识点覆盖率 
1、用0张5元的货币，让[10, 25, 1]组成剩下的1000,最终方法数为 res1 
2、用1张5元的货币，让[10, 25, 1]组成剩下的995,最终方法数为 res2 
3、用2张5元的货币，让[10, 25, 1]组成剩下的990,最终方法数为 res3 
4、用200张5元的货币，让[10, 25, 1]组成剩下的0,最终方法数为 res4 
…. 
最终累计额res即为结果

不足：

如果已经使用0张5元和1张10元的情况下，后续将求：p1(arr, 2, 990) 表示arr剩下 
的钱为arr[2,3]，即[25, 1],990表示要找的剩余钱数 
当已经使用2张5元和0张10元的情况下，后续还是要求p1(arr, 2, 990)，导致又重复之前过程

记忆搜索方法

1、记忆搜索是暴力搜索的优化版，加上了map，避免了重复递归过程 
2、每计算完一个p(index, aim)，都将结果放入map中，index和aim组成 
的KEY，返回结果为Value。 
3、要进入一个递归过程p(index, aim)，线以index和aim注册的KEY在map 
中查询是否已经存在Value，如果存在，则直接取值，如果不存在，才进行 
递归计算

动态规划方法

总程序：

  1. public class Exchange {  
  2.     // 1 动态规划  
  3.     public static int countWays(int[] penny, int n, int aim) {  
  4.         int dp[][] = new int[penny.length][aim + 1];  
  5.         // aim = 0时，第一列的值都为1，表示都有一种方法  
  6.         for (int i = 0; i < n; i++) {  
  7.             dp[i][0] = 1;  
  8.         }  
  9.         // 第一行的值得方法基本能算出来，如果能aim能求余penny[0]，能标记为一种方法  
  10.         for (int i = 1; i <= aim; i++) {  
  11.             if (i % penny[0] == 0) {  
  12.                 dp[0][i] = 1;  
  13.             } else {  
  14.                 dp[0][i] = 0;  
  15.             }  
  16.         }  
  17.         // dp[i][j]的方法是建立在前边的方法之上  
  18.         for (int i = 1; i < n; i++) {  
  19.             for (int j = 1; j <= aim; j++) {  
  20.                 if ((j - penny[i]) >= 0) {  
  21.                     dp[i][j] = dp[i][j - penny[i]] + dp[i - 1][j];  
  22.                 } else {  
  23.                     dp[i][j] = dp[i - 1][j];  
  24.                 }  
  25.             }  
  26.         }  
  27.         return dp[n - 1][aim];  
  28.     }  
  29.   
  30.     // 2 记忆化搜索  
  31.     public static int coins(int[] arr, int aim) {  
  32.         if (arr == null || arr.length == 0 || aim < 0) {  
  33.             return 0;  
  34.         }  
  35.         int[][] map = new int[arr.length + 1][aim + 1];  
  36.         return process(arr, 0, aim, map);  
  37.     }  
  38.   
  39.     public static int process(int[] arr, int index, int aim, int[][] map) {  
  40.         int res = 0;  
  41.         if (index == arr.length) {  
  42.             res = aim == 0 ? 1 : 0;  
  43.   
  44.         } else {  
  45.             int mapValue = 0;  
  46.             for (int i = 0; arr[index] * i <= aim; i++) {  
  47.                 mapValue = map[index + 1][aim - arr[index] * i];  
  48.                 // 每进行递归的时候，都要进行判断，如果之前已经递归过相同的索引和值，则可以直接去其map结果  
  49.                 if (mapValue != 0) {  
  50.                     res += mapValue == -1 ? 0 : mapValue;  
  51.                 } else {  
  52.                     res += process(arr, index + 1, aim - arr[index] * i, map);  
  53.                 }  
  54.             }  
  55.   
  56.         }  
  57.         // 将每个结果保存起来  
  58.         map[index][aim] = res == 0 ? -1 : res;  
  59.         return res;  
  60.   
  61.     }  
  62.   
  63.     // 3 暴力搜索 递归  
  64.     public static int coins1(int[] arr, int aim) {  
  65.         if (arr == null || arr.length == 0 || aim < 0) {  
  66.             return 0;  
  67.         }  
  68.   
  69.         return process(arr, 0, aim);  
  70.     }  
  71.   
  72.     public static int process(int[] arr, int index, int aim) {  
  73.         int res = 0;  
  74.         // 当index为最后时，判断是否满足条件，满足则算为一种方法，不满足则0方法  
  75.         if (index == arr.length) {  
  76.             res = aim == 0 ? 1 : 0;  
  77.   
  78.         } else {  
  79.             // 核心代码，利用了递归的特性  
  80.             // 最后那个值不断递归，直到结尾，前边又加1，后边又不断递归  
  81.             for (int i = 0; arr[index] * i <= aim; i++) {  
  82.   
  83.                 res += process(arr, index + 1, aim - arr[index] * i);  
  84.             }  
  85.   
  86.         }  
  87.         return res;  
  88.   
  89.     }  
  90.   
  91.     public static void main(String[] args) {  
  92.         int[] array = { 5, 10, 25, 1 };  
  93.         int n = 4;  
  94.         int aim = 1000;  
  95.         System.out.println(coins1(array, aim));  
  96.         System.out.println(coins(array, aim));  
  97.         System.out.println(countWays(array, n, aim));  
  98.     }  
  99. }  

台阶问题

情况一

题目描述 有一楼梯共m级，刚开始时你在第一级，若每次只能跨上一级或二级，要走上第m级，共有多少走法？ 注：规定从一级到一级有0种走法。 输入 
输入数据首先包含一个整数n(1<=n<=100)，表示测试实例的个数，然后是n行数据，每行包含一个整数m，（1<=m<=40), 
表示楼梯的级数。 样例 
输入 
2 2 3 
输出 
对于每个测试实例，请输出不同走法的数量。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Main m = new Main();
        while(sc.hasNext()) {
            int num = sc.nextInt();
            for(int i=0; i<num; i++) {
                System.out.println(m.Fan(sc.nextInt()));
            }
        }

    }
    public int Fan(int n) {
        if(n == 1) return 0;
        if(n == 2) return 1;
        if(n == 3) return 2;
        return Fan(n-1)+Fan(n-2);
    }
}

 

情况二

有n级台阶，一个人每次上一级或者两级，问有多少种走完n级台阶的方法。为了防止溢出，请将结果Mod 1000000007 给定一个正整数int 
n，请返回一个数，代表上楼的方式数。保证n小于等于100000。 
测试样例： 1 
返回：1

import java.util.*;

public class GoUpstairs {
    public int countWays(int n) {
        int f1 = 1;
        int f2 = 2;
        int temp = 0;

        for (int i = 3; i <= n; i++){
            // 防止数组越界非法访问等情况
            temp = (f1 + f2) % 1000000007;
            f1 = f2;
            f2 = temp;
        }
        return f2;
    }
}

 

背包问题

一个背包有一定的承重cap，有N件物品，每件都有自己的价值，记录在数组v中，也都有自己的重量，记录在数组w中，每件物品只能选择要装入背包还是不装入背包，要求在不超过背包承重的前提下，选出物品的总价值最大。 
给定物品的重量w价值v及物品数n和承重cap。请返回最大总价值。 
测试样例： [1,2,3],[1,2,3],3,6 
返回：6

import java.util.*;

public class Backpack {
    public int maxValue(int[] w, int[] v, int n, int cap) {
        int[][] dp = new int[n+1][cap+1];
        for (int i = 0; i <= cap; i++){
            dp[0][i] = 0;
        }
        for (int i = 0; i <= n; i++){
            dp[i][0] = 0;
        }
        for (int i = 1; i <= n; i++){
            for (int j = 1; j <= cap; j++){
                // 不选择 i 情况的价值
                dp[i][j] = dp[i-1][j];
                // 选择 i 的情况, 当满足条件时，比较选择与不选择i的最大值
                // w[i-1] 之所以会减一，是因为 i == 1时，表示第一个物品，而w的第一个物品为w[0]。v[i-1]也是如此
                if (j - w[i-1] >= 0){
                    dp[i][j] = Math.max(dp[i][j], dp[i-1][j-w[i-1]] + v[i-1]);
                }
            }
        }
        return dp[n][cap];
    }
}

 

矩阵最小路径和练习题

有一个矩阵map，它每个格子有一个权值。从左上角的格子开始每次只能向右或者向下走，最后到达右下角的位置，路径上所有的数字累加起来就是路径和，返回所有的路径中最小的路径和。 
给定一个矩阵map及它的行数n和列数m，请返回最小路径和。保证行列数均小于等于100. 
测试样例： 
[[1,2,3],[1,1,1]],2,3 
返回：4

import java.util.*;

public class MinimumPath {
    public int getMin(int[][] map, int n, int m) {
        int[][] dp = new int[n][m];
        // dp的第一个元素为map的第一个元素
        dp[0][0] = map[0][0];
        for (int i = 1; i < m; i++){
            dp[0][i] = dp[0][i-1] + map[0][i];
        }
        for (int i = 1; i < n; i++){
            dp[i][0] = dp[i-1][0] + map[i][0];
        }
        for (int i = 1; i < n; i++){
            for (int j = 1; j < m; j++){
                // 求向右或向下的最小值并加上到达位置的map值
                dp[i][j] = Math.min(dp[i-1][j], dp[i][j-1]) + map[i][j];
            }
        }    
        return dp[n-1][m-1];
    }
}

 

LIS练习题

这是一个经典的LIS(即最长上升子序列)问题，请设计一个尽量优的解法求出序列的最长上升子序列的长度。 
给定一个序列A及它的长度n(长度小于等于500)，请返回LIS的长度。 
测试样例： [1,4,2,5,3],5 
返回：3

import java.util.*;

public class LongestIncreasingSubsequence {
    public int getLIS(int[] A, int n) {
        int[] dp = new int[n];
        // 第一个数长度为 1
        dp[0] = 1;
        for (int i = 1; i < n; i++){
            // 求 dp[0] ~ dp[i-1] 的最长子序列 且 A[j] < A[i]
            int maxLength = 0;
            for (int j = 0; j < i; j++){
                if (A[j] < A[i] && maxLength < dp[j]){
                    maxLength = dp[j];
                }
            }
            // 加上本身
            dp[i] = maxLength + 1;
        }
        // 遍历dp，求最大长度子序列
        int maxLength = 0;
        for (int i = 0; i < n; i++){
            if (maxLength < dp[i]){
                maxLength = dp[i];
            }
        }
        return maxLength;
    }
}

 

LCS练习题

给定两个字符串A和B，返回两个字符串的最长公共子序列的长度。例如，A=”1A2C3D4B56”，B=”B1D23CA45B6A”，”123456”或者”12C4B6”都是最长公共子序列。 
给定两个字符串A和B，同时给定两个串的长度n和m，请返回最长公共子序列的长度。保证两串长度均小于等于300。 
测试样例： 
“1A2C3D4B56”,10,”B1D23CA45B6A”,12 
返回：6

import java.util.*;

public class LCS {
    public int findLCS(String A, int n, String B, int m) {
        char[] a = A.toCharArray();
        char[] b = B.toCharArray();
        int[][] dp = new int[n+1][m+1];
        // 为了避免越界，都从数组下标 1 开始
        for (int i = 1; i <= n; i++){
            for (int j = 1; j <= m; j++){
                // 如果两个字符相等，则在之前的基础上 +1
                if (a[i-1] == b[j-1]){
                    dp[i][j] = dp[i-1][j-1] + 1;
                }
                // 求上边或左边的最大值
                else{
                    dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);
                }
            }
        }
        return dp[n][m];
    }
}

 

最优编辑练习题

对于两个字符串A和B，我们需要进行插入、删除和修改操作将A串变为B串，定义c0，c1，c2分别为三种操作的代价，请设计一个高效算法，求出将A串变为B串所需要的最少代价。 
给定两个字符串A和B，及它们的长度和三种操作代价，请返回将A串变为B串所需要的最小代价。保证两串长度均小于等于300，且三种代价值均小于等于100。 
测试样例： “abc”,3,”adc”,3,5,3,100 00 
返回：8

import java.util.*;

public class MinCost {
    // c0 插入， c1 删除， c2 替换
    public int findMinCost(String A, int n, String B, int m, int c0, int c1, int c2) {
        // a编辑成b
        char[] a = A.toCharArray();
        char[] b = B.toCharArray();
        int[][] dp =new int[n+1][m+1];
        // 第一个字符为 ‘’;
        for (int i = 1; i <= m; i++){
            // 行 为 插入
            dp[0][i] = c0 * i;
        }
        for (int i = 1; i <= n; i++){
            // 列 为 删除
            dp[i][0] = c1 * i;
        }

        for (int i = 1; i <= n; i++){
            // 到达 dp[i][j] 一共有四种情况
            for (int j = 1; j <= m; j++){
                // 取最大值，以求出两数比较的最小值
                int temp1 = Integer.MAX_VALUE;
                int temp2 = Integer.MAX_VALUE;
                // 从dp[i-1][j-1] 到 dp[i][j] 的情况，一共两种，相同时为0代价，不同时为 替换 代价；
                if (a[i-1] == b[j-1]){
                    temp1 = dp[i-1][j-1];
                }
                else{
                    // 不同时，替换
                    temp2 = dp[i-1][j-1] + c2;
                }
                // 从 dp[i-1][j] 到 dp[i][j] 的情况， 因为dp[i-1][j] 已经满足了条件b[j-1](从1开始)，可通过删除下一位c1元素则可满足dp[i][j]
                int temp3 = dp[i-1][j] + c1;
                // 从 dp[i][j-1] 到 dp[i][j] 的情况， 因为dp[i-1][j] 还差一个元素就满足b[j-1](从1开始)，可通过插入下一位c0元素则可满足dp[i][j]
                int temp4 = dp[i][j-1] + c0;
                // 从四种情况中选出代价最小的情况
                dp[i][j] = Math.min(Math.min(temp1, temp2), Math.min(temp3, temp4));

            }
        }
        return dp[n][m];
    }
}

posted on 2017-07-26 16:53  WenjieWangFlyToWorld  阅读(124)  评论(0)  编辑  收藏  举报