【算法】动态规划

动态规划是分治思想的延伸，在将大问题化解为小问题的分治过程中，保存对这些小问题已经处理好的结果，并供后面处理更大规模的问题时直接使用这些结果。
动态规划具备了以下三个特点

1. 把原来的问题分解成了几个相似的子问题。
2. 所有的子问题都只需要解决一次。
3. 储存子问题的解。
   动态规划的本质是对问题状态的定义和状态转移方程的定义(状态以及状态之间的递推关系)
   动态规划问题一般从以下四个角度考虑：
   1. 状态定义
   2. 状态间的转移方程定义
   3. 状态的初始化
   4. 返回结果
   状态定义的要求：定义的状态一定要形成递推关系。
   一句话概括：三特点四要素两本质
   适用场景：最大值/最小值, 可不可行, 是不是,方案个数

1. 斐波那契

状态定义：第i项的值
转移方程：f(i) = f(i -1) + f(i - 2)
初始化：f(1) = f(2) = 1
返回结果：f(n)

   public static int ex(int n){
      int f1 = 1;
       int f2 = 1;
       int next = 0;
       if (n<=0)
           return 0;
       if (n == 2|| n == 1){
           return 1;
       }
       for (int i = 3; i <= n; i++) {
          next = f1 + f2;
          f2 = f1;
          f1 = next;
       }
       return next;
   }
   
  public static int ex2(int n){
       if (n == 0 || n == 1){
           return n;
       }
        int sum = ex2(n - 1) + ex2(n - 2);
       return sum;
  }

2. 跳台阶

一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
状态f(i)：跳上i级台阶的方法数
状态定义：第i项的值
转移方程：f(i) = f(i -1) + f(i - 2) + … +f(1) ，f(i - 1) = f(i - 2) + … +f(1) …
总结一下：f(i) = 2*f(i -1)
调到第i - 1层再跳一层有f(i - 1)个跳法，调到第i - 2层再跳两层有f(i - 2)种跳法…
初始化：f(1) = 1
返回结果：f(n)

public class ex2 {
    public static void main(String[] args) {
        System.out.println(JumpFloorII(5));
    }

    public static int JumpFloorII(int target) {
        int f1 = 1;
        int next = 0;
        if(target <= 0)
            return 0;
        if(target == 1)
            return 1;
        for(int i = 2; i <= target; i++){
            next = 2*f1;
            f1 = next;
        }
        return next;
    }

    public  static int JumpFloorII2(int target) {
        int f1 = 1;
        int next = 0;
        if (target == 1){
            return 1;
        }
        next = 2*JumpFloorII2(target -1 );
        return next;
    }
}

也可以理解为除了最后一节台阶都有2种跳法（跳或者不跳）。2^(n -1)

变形:覆盖矩形

我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2n的大矩形，总共有多少种方法？
状态f(i): 用i个21的矩形拼成一个2*n的大矩形，有横竖两种方法。
f(i) = f(i -1) + f(i -2)

3.最大连续子数组和

例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和。
F(i)：以第i项结尾的连续子序列的最大和
F(i)：max(F(i - 1)) + a[i]，a[i])
F(1)：6 = 6
F(2)：6，-3 = 3
F(3)：6，-3，-2 = 1
F(4)：6，-3，-2，7 = 8
F(5)：6，-3，-2，7，-15 = -7
F(6)：1 = 1
F(7)：1，2， = 3
F(8)：1，2，2 = 5

public class Solution {
    public int FindGreatestSumOfSubArray(int[] array) {
        int next = array[0];
        int max = array[0];
        for(int i = 1; i < array.length; i++){
            next = Math.max(next + array[i],array[i]);//加上上一项或者不加
            max = Math.max(max,next);//找到不同组合中值最大的那一个
        }
        return max;
    }
}

4.word-break

给定一个字符串s和一组单词dict，判断s是否可以用空格分割成一个单词序列，使得单词序列中所有的单词都是dict中的单词（序列可以包含一个或多个单词）。
例如:
给定s=“leetcode”；
dict=[“leet”, “code”].
返回true，因为"leetcode"可以被分割成"leet code".
题目中的例子不够明显，重新举一个例子：
s = “1234567890”
dict = [“12”,“34”,“56”,“78”,“90”]
F(0) --> “”
默认F(0) 为空
F(1) --> “1” : " “，“1”
F(1)可以看做是F(0) 和在字典中找第一个字符串明显为false F(0)&&dict.find(“1”) false
F(2) --> “12”:“1”,“2” 或” " “12”
F(2) 可以看做是找"12"或者"1",“2”：即：F(0) && dict.find(“12”) 可以在字典中找到12所以为true 。后面的dict.find(“1”) || dict.find(“2”) 可以不去考虑了。
F(3) --> “123”:"1"“23”,"12"“3”:即：F(2)&& dict.find(“3”)|| F(1)&& dict.find(“23”) || dict.find(“123”)&&F(0) false
F(4) --> F(3) && dict.find(“4”) || F(2) && dict.find(“34”) || 。。。true
F(5) --> F(4) && dict.find(“5”)|| F(3) && dict.find(“45”)||。。。 false
。。。
F(10) --> F(8)&&dict.find(“90”)||。。。 true
F(i) : F(j) && dict.find(s(j +1,i))

import java.util.*;
public class Solution {
    public boolean wordBreak(String s, Set<String> dict) {
       boolean[] bool = new boolean[s.length()+ 1];
        bool[0] = true;
        for(int i = 1; i <= s.length(); i++){
            //遍历之前的状态
            for(int j = 0; j < i; j++){
                if(bool[j] && dict.contains(s.substring(j,i))){
                    bool[i] = true;
                    break;
                }   
            }
        }
        return bool[s.length()];
    }
}

5.三角矩阵

给出一个三角形，计算从三角形顶部到底部的最小路径和，每一步都可以移动到下面一行相邻的数字，
例如，给出的三角形如下：.
[↵ [2],↵ [3,4],↵ [6,5,7],↵ [4,1,8,3]↵]
最小的从顶部到底部的路径和是2 + 3 + 5 + 1 = 11。
注意：
如果你能只用O（N）的额外的空间来完成这项工作的话，就可以得到附加分，其中N是三角形中的行总数。
注：这是一个等腰三角形。
（i,j） -----> （i + 1,j）（i + 1,j + 1） (i,j) <----- (i - 1,j) ,(i -1,j -1)
可以发现一个规律：第l个数组的第k个元素的下一个元素的有两种可能，分别是第l+1个数组的第k个元素与第k+1个元素
状态F(i,j):从（0，0）到（i，j）的最短路径
F(i,j) = min(F(i -1,j)),F(i -1,j -1) + a[i][j]
每行的第一个元素：F(i,0) = F(i -1,0) + a[i][0]
每行的最后一个元素：F(i,i) = F(i - 1,i -1) + a[i][i]
初始状态：F（0,0）= a[0][0]
返回：min(F(row - 1),j),最后一行的一个元素

import java.util.*;
public class Solution {
    public int minimumTotal(ArrayList<ArrayList<Integer>> triangle) {
        for (int i = triangle.size() - 2; i >= 0; i --) {
            for (int j = 0; j < triangle.get(i + 1).size() - 1; j ++) {
                int min = Math.min(triangle.get(i + 1).get(j), triangle.get(i + 1).get(j + 1));
                triangle.get(i).set(j, triangle.get(i).get(j) + min);
            }
        }
        return triangle.get(0).get(0);
    }
}

6. 路径总数

题目描述
一个机器人在m×n大小的地图的左上角（起点，下图中的标记“start"的位置）。
机器人每次向下或向右移动。机器人要到达地图的右下角。（终点，下图中的标记“Finish"的位置）。
可以有多少种不同的路径从起点走到终点？

状态F(i,j):从左上角到达(i,j)的路径总数。
F(i,j) = F(i -1,j) + F(i,j -1)
F(0,0) = 0
F(0,j) = 1,F(i,0) = 1
创建一个二维数组，存储从（1，1）到此点的路径数。

public class Solution {
    public int uniquePaths(int m, int n) {
        int[][] dp = new int[m][n];
        for(int i = 0; i <  m; i++){
            dp[i][0] = 1;
        }
        for(int j = 0; j < n; j++){
            dp[0][j] = 1;
        }
        for(int i = 1; i < m; i++){
            for(int j = 1; j < n; j++){
                dp[i][j] = dp[i - 1][j] + dp[i][j -1];
            }
        }
        return dp[m -1][n - 1];
    }
}

7.路径总数扩展

如果在图中加入了一些障碍，有多少不同的路径？
分别用0和1代表空区域和障碍
例如
下图表示有一个障碍在3*3的图中央。
[↵ [0,0,0],↵ [0,1,0],↵ [0,0,0]↵]
有2条不同的路径
备注：m和n不超过100.

状态F(i,j):从左上角到达(i,j)的路径总数。
a[i][j] = 0:
F(i,j) = F(i -1,j) + F(i,j -1)
a[i][j] = 1:
F(i)(j) = 0
F(0,0) = 0
F(0) =
F(0,j) = 1,F(i,0) = 1

public int ex(int[][] obstacleGrid){
   int m = obstacleGrid.length;//行
     int n = obstacleGrid[0].length;//列
     int[][] b = new int[m][n];
     for (int i = 0; i < m ; i++) {
         if (obstacleGrid[i][0] == 1){
              break;
         }else
             b[i][0] = 1;
     }
     for (int j = 0; j < n ; j++) {
         if (obstacleGrid[0][j] == 1){
             break;
         }else
             b[0][j] = 1;
     }
     for (int i = 1; i < m; i++){
         for (int j  = 1; j < n; j++){
             if (obstacleGrid[i][j] == 0)
                 b[i][j] = b[i - 1][j] + b[i][j - 1];
         }
     }
     return b[m -1][n -1];
 }

8.最小路径和(Minimum Path Sum)

给定一个由非负整数填充的m x n的二维数组，现在要从二维数组的左上角走到右下角，请找出路径上的所有数字之和最小的路径。
注意：你每次只能向下或向右移动。

public class Solution {
    public int minPathSum(int[][] grid) {
        int m = grid.length;
         int n = grid[0].length;
        int[][] dp = new int[m][n];
        dp[0][0] = grid[0][0];
        for(int i = 1; i <  m; i++){
            dp[i][0] = dp[i - 1][0] + grid[i][0];
        }
        for(int j = 1; j < n; j++){
            dp[0][j] = dp[0][j - 1] + grid[0][j];
        }
        for(int i = 1; i < m; i++){
            for(int j = 1; j < n; j++){
                dp[i][j] = Math.min(dp[i - 1][j],dp[i][j -1]) + grid[i][j];
            }
        }
        return dp[m -1][n - 1];
    }
}

9.背包问题

有 n 个物品和一个大小为 m 的背包. 给定数组 A 表示每个物品的大小和数组 V 表示每个物品的价值.
问最多能装入背包的总价值是多大?
注：
A[i], V[i], n, m 均为整数
你不能将物品进行切分
你所挑选的要装入背包的物品的总大小不能超过 m
每个物品只能取一次

状态F(i,j)：看到前i个商品，包内物大小为j的最大价值。
F(i,j) ：
A[i] > j 当商品大小大于背包总容量，则直接跳过此商品。F(i -1,j)
A[i] <= j
1.如果新的商品放进去价值反而减小了（因为有可能需要拿出其他商品），则还是跳过此商品。F(i -1,j)
2. 如果条件合适放进去：
需要从前i- 1个商品中腾出A[i]个空间：F(i-1,j - A[i])，加上当前商品的价值F(i-1,j - A[i]) + V[i]

例：
F(1,1):24…F(1,8):24
F(2,1):24…F(2,2):24…F(2,3):F(1,3 - 2) + 1 = 25…F(2,8):25
F(3,1):24…F(3,3):1024

10.回文串分割(Palindrome Partitioning)

给出一个字符串s，分割s使得分割出的每一个子串都是回文串
计算将字符串s分割成回文分割结果的最小切割数
例如:给定字符串s=“aab”,
返回1，因为回文分割结果[“aa”,“b”]是切割一次生成的。
状态F(i):前i个字符的最小分割次数
F(i):1~j F(j)(j < i)