动态规划算法常见题型

动态规划算法常见题型

一、基本概念

动态规划过程是：每次决策依赖于当前状态，又随即引起状态的转移。一个决策序列就是在变化的状态中产生出来的，所以，这种多阶段最优化决策解决问题的过程就称为动态规划。

二、基本思想与策略

基本思想与分治法类似，也是将待求解的问题分解为若干个子问题（阶段），按顺序求解子阶段，前一子问题的解，为后一子问题的求解提供了有用的信息。在求解任一子问题时，列出各种可能的局部解，通过决策保留那些有可能达到最优的局部解，丢弃其他局部解。依次解决各子问题，最后一个子问题就是初始问题的解。 由于动态规划解决的问题多数有重叠子问题这个特点，为减少重复计算，对每一个子问题只解一次，将其不同阶段的不同状态保存在一个二维数组中。 与分治法最大的差别是：适合于用动态规划法求解的问题，经分解后得到的子问题往往不是互相独立的（即下一个子阶段的求解是建立在上一个子阶段的解的基础上，进行进一步的求解）。 以上都过于理论，还是看看常见的动态规划问题吧！！！

三、常见动态规划问题 1.硬币找零问题 详见http://blog.csdn.net/yyl424525/article/details/55192771

2.求两字符序列的最长公共字符子序列 问题描述：

字符序列的子序列是指从给定字符序列中随意地（不一定连续）去掉若干个字符（可能一个也不去掉）后所形成的字符序列。令给定的字符序列X=“x0，x1，…，xm-1”，序列Y=“y0，y1，…，yk-1”是X的子序列，存在X的一个严格递增下标序列i0，i1，…，ik-1，使得对所有的j=0，1，…，k-1，有xij=yj。例如，X=“ABCBDAB”，Y=“BCDB”是X的一个子序列。 考虑最长公共子序列问题如何分解成子问题，设A=“a0，a1，…，am-1”，B=“b0，b1，…，bm-1”，并Z=“z0，z1，…，zk-1”为它们的最长公共子序列。不难证明有以下性质： （1） 如果am-1=bn-1，则zk-1=am-1=bn-1，且“z0，z1，…，zk-2”是“a0，a1，…，am-2”和“b0，b1，…，bn-2”的一个最长公共子序列； （2） 如果am-1!=bn-1，则若zk-1!=am-1，蕴涵“z0，z1，…，zk-1”是“a0，a1，…，am-2”和“b0，b1，…，bn-1”的一个最长公共子序列； （3） 如果am-1!=bn-1，则若zk-1!=bn-1，蕴涵“z0，z1，…，zk-1”是“a0，a1，…，am-1”和“b0，b1，…，bn-2”的一个最长公共子序列。 这样，在找A和B的公共子序列时，如有am-1=bn-1，则进一步解决一个子问题，找“a0，a1，…，am-2”和“b0，b1，…，bm-2”的一个最长公共子序列；如果am-1!=bn-1，则要解决两个子问题，找出“a0，a1，…，am-2”和“b0，b1，…，bn-1”的一个最长公共子序列和找出“a0，a1，…，am-1”和“b0，b1，…，bn-2”的一个最长公共子序列，再取两者中较长者作为A和B的最长公共子序列。

求解：

引进一个二维数组c[][]，用c[i][j]记录X[i]与Y[j] 的LCS 的长度，b[i][j]记录c[i][j]是通过哪一个子问题的值求得的，以决定搜索的方向。 我们是自底向上进行递推计算，那么在计算c[i,j]之前，c[i-1][j-1]，c[i-1][j]与c[i][j-1]均已计算出来。此时我们根据X[i] = Y[j]还是X[i] != Y[j]，就可以计算出c[i][j]。

问题的递归式写成：

回溯输出最长公共子序列过程： 算法分析：

由于每次调用至少向上或向左（或向上向左同时）移动一步，故最多调用(m + n)次就会遇到i = 0或j = 0的情况，此时开始返回。返回时与递归调用时方向相反，步数相同，故算法时间复杂度为Θ(m + n)。

代码：

#include <stdio.h> #include <string.h> #define MAXLEN 100 void LCSLength(char *x, char *y, int m, int n, int c[][MAXLEN], int b[][MAXLEN]) { int i, j; for(i = 0; i <= m; i++) c[i][0] = 0; for(j = 1; j <= n; j++) c[0][j] = 0; for(i = 1; i<= m; i++) { for(j = 1; j <= n; j++) { if(x[i-1] == y[j-1]) { c[i][j] = c[i-1][j-1] + 1; b[i][j] = 0; } else if(c[i-1][j] >= c[i][j-1]) { c[i][j] = c[i-1][j]; b[i][j] = 1; } else { c[i][j] = c[i][j-1]; b[i][j] = -1; } } } } void PrintLCS(int b[][MAXLEN], char *x, int i, int j) { if(i == 0 || j == 0) return; if(b[i][j] == 0) { PrintLCS(b, x, i-1, j-1); printf("%c ", x[i-1]); } else if(b[i][j] == 1) PrintLCS(b, x, i-1, j); else PrintLCS(b, x, i, j-1); } int main(int argc, char **argv) { char x[MAXLEN] = {"ABCBDAB"}; char y[MAXLEN] = {"BDCABA"}; int b[MAXLEN][MAXLEN]; int c[MAXLEN][MAXLEN]; int m, n; m = strlen(x); n = strlen(y); LCSLength(x, y, m, n, c, b); PrintLCS(b, x, m, n); return 0; }

Java版

import java.util.Scanner; //最长公共子序列 //c[i][j]记录x[i]与y[j]的LCS的长度，b[i][j]记录c[i][j]是通过哪个子问题的解得到的，以决定搜索方向 public class Lcs { static int b[][],c[][]; static int m,n; static String xString,yString; public static void main(String [] args){ Scanner scanner=new Scanner(System.in); xString=scanner.nextLine(); yString=scanner.nextLine(); m=xString.length(); n=yString.length(); b=new int[m+1][n+1]; c=new int[m+1][n+1]; getLcs(); printLcs(m,n); } private static void printLcs(int m,int n) { if(m==0||n==0) return ; if(b[m][n]==1) { printLcs(m-1, n-1); System.out.print(xString.charAt(m-1)); } else if(b[m][n]==2) { printLcs(m, n-1); }else if(b[m][n]==3) { printLcs(m-1, n); } } private static void getLcs() { for(int i=1;i<=m;i++) { for(int j=1;j<=n;j++) { if(xString.charAt(i-1)==yString.charAt(j-1)) { c[i][j]=c[i-1][j-1]+1; b[i][j]=1; }else if(c[i][j-1]>=c[i-1][j]) { c[i][j]=c[i][j-1]; b[i][j]=2; }else { c[i][j]=c[i-1][j]; b[i][j]=3; } } } } }

3.走台阶问题 有n级台阶，一个人每次上一级或者两级，问有多少种走完n级台阶的方法。为了防止溢出，请将结果Mod 1000000007 给定一个正整数int n，请返回一个数，代表上楼的方式数。保证n小于等于100000。 测试样例： 1 返回：1 解析： 设DP[i]为走到第i层一共有多少种方法，那么DP[80]即为所求。很显然DP[1]=1, DP[2]=2（走到第一层只有一种方法：就是走一层楼梯；走到第二层有两种方法：走两次一层楼梯或者走一次两层楼梯）。同理，走到第i层楼梯，可以从i-1层走一层，或者从i-2走两层。很容易得到： // 递推公式：DP[i]=DP[i-1]+DP[i-2] // 边界条件：DP[1]=1 DP[2]=2

public class ClimbStairs { public static void main(String[] args) { Scanner scanner=new Scanner(System.in); int n=scanner.nextInt(); System.out.println(climbStair(n)); System.out.println(climbStair2(n)); } //自顶向下一般采用递归 private static int climbStair(int n) { if(n==1) return 1; if(n==2) return 2; else return climbStair(n-1)+climbStair(n-2); } //自顶向上一般采用数组填表方式 private static int climbStair2(int n) { int []temp=new int[n+1]; temp[1]=1; temp[2]=2; for (int i = 3; i <=n ; i++) { temp[i]=temp[i-1]+temp[i-2]; } return temp[n]; } }