算法-动态规划DP小记

动态规划算法是一种比较灵活的算法，针对具体的问题要具体分析，其宗旨就是要找出要解决问题的状态，然后逆向转化为求解子问题，最终回到已知的初始态，然后再顺序累计各个子问题的解从而得到最终问题的解。

关键点就是找到状态转移方程和初始边界条件，说白了就是要找到“递推公式”和初始值，然后计算时保存每一步中间结果，最后累加判断得到结果。

0.求数组最值

求数组最值方法很多，这里使用动态规划的思想来尝试处理，以便更好地理解DP的思想。为了方便这里假设数组a[i]大小为n，要找n个数当中的最大值。

设dp[i]表示第0...i个数的最大值，dp[i-1]表示第0...i-1个数的最大值，所以求前i个数的最大值时，已经知道前i-1个是的最大值是dp[i-1]，那么只需要比较dp[i-1]和第i个数谁大就知道了，即dp[i] = max(dp[-1], a[i])。

	public int max(int[] a){
		int len = a.length;
		int[] dp = new int[len];
		dp[0] = a[0];
		for(int i=1; i<len; i++){
			dp[i] = (dp[i-1] > a[i]) ? dp[i-1] : a[i];
		}
		return dp[len-1];
	}

1.求最大公共子序列长度

给定一个字符串，想要删掉某些字符使得最后剩下的字符构成一个回文串（左右对称的字符串，如abcba），问最少删掉多少个字符可获得一个最长回文串。

    /**
      * 本题求回文串最大长度就转化为求两个字符串的最长公共子序列（不一定连续）
      * 策略：字符串可以看做是字符序列，即字符数组。
      *      比如有序列A=a0,a1,a2...an；有序列B=b0,b1,b2,b3...bm；设A序列和B序列的公共子序列为C=c0,c1,c2,c3...ck。
      *      设L[][]为公共子序列C的长度，L[i][j]的i、j分别表示A、B序列的字符下标，L[i][j]含义是A序列a0、a1、a2...ai和B序列b0、b1、b2、
      *      ...bj的公共子序列的长度。
      *
      *      1）如果A序列的i字符和B序列的j字符相等，那么就有ck=ai=bj，公共子序列C的长度L[i][j]=L[i-1][j-1]+1。
      *      2）如果A序列的i字符和B序列的j字符不相等，若ai != ck则C为a0...ai-1和b0...bj的最长子序列，若bj != ck则C为a0...ai和b0...bj-1的最长子序列，
      *         所以此时公共子序列长度为L[i][j] = max(L[i][j-1], L[i-1][j])。
      */
    public static int lcs(String s){
        if (s == null  ) {
            return -1;
        }
        String rs = new StringBuilder(s).reverse().toString();
        char[] chars1 = s.toCharArray();
        char[] chars2 = rs.toCharArray();//获得反序的字符串
        int n = chars1.length;
        int[][] dp = new int[n+1][n+1];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if(chars1[i] == chars2[j]){
                    dp[i][j] = dp[i-1][j-1] + 1;
                }else {
                    dp[i][j] = dp[i][j-1] > dp[i-1][j] ? dp[i][j-1] : dp[i-1][j];
                }
            }
        }
        return n - dp[n][n];
    }

2.硬币凑钱问题

只有面值为1元、3元、5元的硬币，数量足够。现在要凑够n元，求需要的最少硬币枚数。


    /**
     *
     * @param n 目标总钱数
     * @param coins 硬币数组【1，3，5】
     * @return 返回凑够n元需要的最少硬币数
     */
    public static int getLeastCoinAmount(int n, int[] coins){
        if (coins == null || n < 0) {
            return -1;
        }
        if (n == 0){
            return 0;
        }
        int[] dp = new int[n+1]; //dp[i]=j表示凑够i元最少需要j枚硬币。数组长度设为（n+1）保证可以访问dp[n]。
        dp[0] = 0;
        for (int i = 1; i <= n; i++) {
            dp[i] = Integer.MAX_VALUE;
        }
        int coinValue = 0;
        for (int i = 1; i <= n; i++) {//问题规模从小到大，直到达到目标面值
            for (int j = 0; j < coins.length; j++) {//遍历所有面值的硬币，j表示硬币面值的下标
                coinValue = coins[j];
                if (i - coinValue >= 0 && 1 + dp[i-coinValue] < dp[i]){ //当前方案的硬币数更少，则使用当前方案
                    dp[i] = 1 + dp[i-coins[j]];
                }
            }
        }
        return dp[n];
    }

3.最长非降子序列

一个序列有N个数：A[1],A[2],…,A[N]，求出最长非降子序列的长度。


    /**
     *
     * 定义d(i)表示前i个数中"以A[i]结尾"的最长非降子序列的长度。
     * 对序列A1...Ai,找到的最长子序列长度d[i]分两种情况：
     * （1）包含最后一个数Ai,即d[i]=max{d[j]+1}(1<=j<i且Aj<=Ai)，满足条件的Aj可能会有多个，选最大的d[j]，如果Aj都大于Ai则d[j]=0；
     * （2）不含最后一个数,即d[i]=d[i-1]
     *
     * 综上：d[i] = max{d[i-1], max{d[j]+1}}
     */
    public static int longestIncreasingSubsequence(int[] a){
        if (a == null) {
            return -1;
        }
        if (a.length < 1){
            return 0;
        }
        int len = a.length;
        int[] dp = new int[len];//dp[i]系统自动初始化为0
        dp[0] = 1;
        for (int i = 1; i < len; i++) {//迭代，求序列0...len-1的最长子序列长度
            for (int j = 0; j < i; j++) {//寻找Ai之前的序列，看是否有不大于Ai的数字Aj
                if (a[j] <= a[i] && dp[i] < dp[j] + 1){//假设最长子序列包含最后一个数
                    dp[i] = dp[j] + 1;
                }
            }
            //寻找Ai之前的序列如果Ai都小于Aj，此时dp[i]并没有被修改仍为初始值0。所以包含最后一个数的最长子序列就只有最后一个数自身，长1
            dp[i] = Math.max(1, dp[i]);
            //至此，已经求出了包含最后一个数的最长子序列的长度，和不包含最后一个数的最长子序列长度比较，取最大值为当前的最大长度
            dp[i] = Math.max(dp[i], dp[i-1]);
        }
        return dp[len-1];
    }

4.经典01背包问题

01背包问题：一个承重（或体积）为W的背包，可选物品有n个，第i个物品分别重w[i]和价值v[i]，每个物品只能拿或不拿，求背包可放物品的最大价值。


    /**
     *
     * 策略：这里的关键制约因素是背包只能承重w，而且每放入一个物品其承重就会减少。
     *      因此定义maxValue=V[i][j]，数组表示目前可选物品有i个：0、1...i-1，背包承重（剩余的存放重量）为j的最大价值。
     *      现在假设已经知道了(i-1)个物品且剩余承重为j的最大价值V[i-1][j]，那么考虑准备放入第i个物品的情况：
     *     （1）如果第i个物品的重量大于背包的剩余承重w_i>j，显然放不下了，所以此时V[i][j]=V[i-1][j];
     *      (2)w_i<=j，显然可以放下第i个物品，物品可以放得下，但是一定要装进来吗？如果装进的物品价值较低且较重，无疑会影响后续物品的装入情况。
     *        所以还要考虑要不要放进来的子问题，V[i][j]=max{vi+V[i-1][j-wi], V[i-1][j]}。
     *
     * @param W
     * @param n
     * @param w
     * @param v
     * @return
     */
    public static int knapsack(int W, int n, int[] w, int[] v){
        if ( W < 1 || n < 1 || w == null || v == null) {
            return -1;
        }
        int[][] dp = new int[n+1][W+1]; //可选的物品最多可以有n个，所以行数设为n+1。最大承重是W，所以列设为W+1。
        int index = 0;
        for (int i = 1; i <= n; i++) { //物品数肯定是从1开始。dp[0][j]系统初始化为0.
            index = i-1;
            for (int j = 1; j <= W ; j++) {//能装进的重量肯定是从1开始。dp[i][0]系统初始化为0.
                if (w[index] > j){
                    dp[i][j] =  dp[i-1][j];
                }else {
                    dp[i][j] =  Math.max(dp[i - 1][j - w[index]] + v[index], dp[i - 1][j]);
                }
            }
        }
        //找出是哪些物品放入背包
        boolean[] isTaken = new boolean[n];//标记是否放入背包里
        for (int i = n; i > 0 ; i--) {
            if (dp[i][W] != dp[i-1][W]){
                isTaken[i-1] = true;//装入
                W -= w[i-1];//装入之后背包的承重减少
                System.out.println(i-1);
            }
        }
        return dp[n][W];//返回n个物品承重为W时的最大价值
    }
}