动态规划算法详解及经典例题

动态规划

什么是动态规划？

动态规划的大体思路是把一个复杂的问题转化成一个分阶段逐步递推的过程，从简单的初始状态一步一步递推，最终获得复杂问题的最优解。

基本思想与策略编辑:

因为动态规划解决的问题多数有重叠子问题这个特色，为减小重复计算，对每个子问题只解一次，将其不一样阶段的不一样状态保存在一个二维数组中。

　　1. 拆分问题：根据问题的可能性把问题划分红经过递推或者递归一步一步实现。

关键就是这个步骤,动态规划有一类问题就是从后往前推到,有时候咱们很容易知道 : 若是只有一种状况时,最佳的选择应该怎么作.而后根据这个最佳选择往前一步推导,获得前一步的最佳选择

　　2. 定义问题状态和状态之间的关系：用一种量化的形式表现出来,相似于高中学的推导公式,由于这种式子很容易用程序写出来,也能够说对程序比较亲和(也就是最后所说的状态转移方程式)

　　3. 动态规划算法的基本思想与分治法相似，也是将待求解的问题分解为若干个子问题（阶段），按顺序求解子阶段，前一子问题的解，为后一子问题的求解提供了有用的信息。在求解任一子问题时，列出各类可能的局部解，经过决策保留那些有可能达到最优的局部解，丢弃其余局部解。依次解决各子问题，最后一个子问题就是初始问题的解。

个人理解是：好比咱们找到最优解,咱们应该讲最优解保存下来,为了往前推导时可以使用前一步的最优解,在这个过程当中不免有一些相比于最优解差的解,此时咱们应该放弃,只保存最优解,

这样咱们每一次都把最优解保存了下来,大大下降了时间复杂度。

 

动态规划解决问题的过程分为两步：

1.寻找状态转移方程式

2.利用状态转移方程式自底向上求解问题

 

动态规划原理

使用条件：可分为多个相关子问题，子问题的解被重复使用

• 使用条件：可分为多个相关子问题，子问题的解被重复使用

• Optimal substructure（优化子结构）：

• • 一个问题的优化解包含了子问题的优化解

• • 缩小子问题集合，只需那些优化问题中包含的子问题，下降实现复杂性

• • 咱们能够自下而上的

• Subteties（重叠子问题）：在问题的求解过程当中，不少子问题的解将被屡次使用。

• 动态规划算法的设计步骤：
  • 分析优化解的结构
  • 递归地定义最优解的代价
  • 自底向上地计算优化解的代价保存之，并获取构造最优解的信息
  • 根据构造最优解的信息构造优化解
• 动态规划特色：
  • 把原始问题划分红一系列子问题；
  • 求解每一个子问题仅一次，并将其结果保存在一个表中，之后用到时直接存取，不重复计算，节省计算时间
  • 自底向上地计算。
  • 总体问题最优解取决于子问题的最优解（状态转移方程）（将子问题称为状态，最终状态的求解归结为其余状态的求解）

 

最长公共子序列的动态规划法实现

最长公共子序列（longest-common-subsequence, LCS） 

   （1）子序列：一个序列X ＝ x1x2...xn,中任意删除若干项，剩余的序列叫作A的一个子序列。也能够认为是从序列A按原顺序保留任意若干项获得的序列。
      例如：对序列 1,3,5,4,2,6,8,7来讲，序列3,4,8,7 是它的一个子序列。对于一个长度为n的序列，它一共有2^n 个子序列，有(2^n – 1)个非空子序列。在这里须要提醒你们，子序列不是子集，它和原始序列的元素顺序是相关的。

   （2）公共子序列：若是序列Z既是序列X的子序列，同时也是序列Y的子序列，则称它为序列X和序列Y的公共子序列。空序列是任何两个序列的公共子序列。

   （3）最长公共子序列：X和Y的公共子序列中长度最长的（包含元素最多的）叫作X和Y的最长公共子序列。

      这个问题若是用穷举法时间，最终求出最长公共子序列时，时间复杂度是Ο（2mn），是指数级别的复杂度，对于长序列是不适用的。所以咱们使用动态规划法来求解。

刻画最长公共子序列问题的最优子结构 

      设X=x₁x₂…x_m和Y=y₁y₂…y_n是两个序列，Z=z₁z₂…z_k是这两个序列的一个最长公共子序列。

      1.  若是x_m=y_n，那么z_k=x_m=y_n，且Z_k-1是X_m-1，Y_n-1的一个最长公共子序列；

      2.  若是x_m≠y_n，那么z_k≠x_m，意味着Z是X_m-1，Y的一个最长公共子序列；

      3.  若是x_m≠y_n，那么z_k≠y_n，意味着Z是X，Y_n-1的一个最长公共子序列。

      从上面三种状况能够看出，两个序列的LCS包含两个序列的前缀的LCS。所以，LCS问题具备最优子结构特征。

 

递归的定义最优值 

    从最优子结构能够看出，若是x_m=y_n，那么咱们应该求解X_m-1，Y_n-1的一个LCS，而且将x_m=y_n加入到这个LCS的末尾，这样获得的一个新的LCS就是所求。

    若是xm≠yn，咱们须要求解两个子问题，分别求X_m-1，Y的一个LCS和X，Y_n-1的一个LCS。两个LCS中较长者就是X和Y的一个LCS。

    能够看出LCS问题具备重叠子问题性质。为了求X和Y的一个LCS，咱们须要分别求出X_m-1，Y的一个LCS和X，Y_n-1的一个LCS，这几个字问题又包含了求出X_m-1，Y_n-1的一个LCS的子子问题。（有点绕了。。。晕没晕。。。。）

    根据上面的分析，咱们能够得出下面的公式；

 

 

计算最优解的值

       根据上面的，咱们很容易就能够写出递归计算LCS问题的程序，经过这个程序咱们能够求出各个子问题的LCS的值，此外，为了求解最优解自己，咱们好须要一个表dp，dp[i，j]记录使C[i，j]取值的最优子结构。

 

数组的填表过程

代码实现：

package cn.itcast.recursion; public class LCS { public int findLCS(String A, String B) { int n = A.length(); int m = B.length(); //返回一个字符数组，该字符数组中存放了当前字符串中的全部字符 //返回的是字符数组char[]a
        char[] a = A.toCharArray(); char[] b = B.toCharArray(); //建立一个二维矩阵，用来推到公共子序列
        int[][] dp = new int[n][m]; for (int i = 0; i < n; i++) { //若是找到第一列其中一个字符等于第一行第一个字符
            if (a[i] == b[0]) { //找到第一列与第一行b[0]的相等的值，把其变成1
                dp[i][0] = 1; //并将其后面的字符都变成1
                for (int j = i + 1; j < n; j++) { dp[j][0] = 1; } break; } } for (int i = 0; i < m; i++) { //若是找到第一列其中一个字符等于第一行第一个字符
            if (b[i] == a[0]) { //则把第一列后面的字符都变成1
                dp[0][i] = 1; for (int j = i + 1; j < m; j++) { dp[0][j] = 1; } break; } } //从1开始是由于横向和纵向下标为0的都遍历过了
        for (int i = 1; i < n; i++) { for (int j = 1; j < m; j++) { //横向和纵向有相等的值
                if (a[i] == b[j]) { //当前位置左边的值+1
                    dp[i][j] = dp[i - 1][j - 1] + 1; } else { //取当前位置（左边的值，上边的值）的最大值
                    dp[i][j] = Math.max(dp[i][j - 1], dp[i - 1][j]); } } } for (int i = 0; i < n - 1; i++) { for (int j = 0; j < m; j++) { System.out.print(dp[i][j] + "  "); } System.out.println(); } return dp[n - 1][m - 1]; } public static void main(String[] args) { LCS lcs = new LCS(); int findLCS = lcs.findLCS("android", "random"); System.out.println("最长子序列长度：" + findLCS); } }