动态规划（Dynamic Programming，简称DP），需要分解出问题的子结构以及通过子结构重新构造最优解。动态规划不像回溯法，有套路可以套用，动态规划需要大量练习，才能掌握规律。
一般思路:
1.判断问题的子结构，有最优子结构时，可用动态规划！！（即从子问题的最优解，就能拼接出整体的最优解！！）
2.求解重叠子问题。一个递归算法不断地调用同一问题（子问题大量重复，可以存储，减少计算），递归可以转化为查表从而利用子问题的解。（注意与分治法区别开，分治法每次递归都产生新的问题）
特殊思路：备忘录法
备忘录法是动态规划的一种变形，最开始随机填一个数字，遇到子问题时，计算并填表。
实例可参照矩阵链乘法。
常见题目：
1. 硬币找零：假设有1,3,5三种硬币，数量无限，问当总额为某个值时需要最少硬币数为多少。
2. 装配线调度：某个工厂有两条装配线，汽车底盘经过每个流程时都有相应的时间消耗，问怎么安排，可以让进入流水线到出厂时，总时间最少。
3. 字符串相似度/编辑距离（edit distance）
有两个不同的字符串，只对一个字符串进行“增删改”操作，每次变化只有一个字符，问变成另一个字符串时，最少操作几次？
4.最长公共子序列(Longest Common Subsequence,LCS)
对于序列S和T，求它们的最长公共子序列。例如X={A,B,C,B,D,A,B}，Y={B,D,C,A,B,A}则它们的LCS是{B,C,B,A}和{B,D,A,B}。求出一个即可。
5.铺瓷砖问题（剑指offer，编程之美原题）
用 1 * 2 的瓷砖覆盖 n * m 的地板，问共有多少种覆盖方式？
答：可以转换为斐波那契数列题。f(n)=f(n-1)+f(n-2);
题目背景如下：有一个背包，容量有限。还有好几样物品，体积和价值各不相同，如何尽量装最高价值的物品呢？用实际数据举例如下：
* 物品编号： 1 2 3 4
* 物品体积： 2 3 4 5
* 物品价值： 3 4 5 6
即前i件物品，容积为j时，最大价值为dp[i][j]，用图表法计算如下：
有3种可能。
总容量连当前物品都放不下，那么当前物品肯定不放。前i个物品总体组合与前i-1一致。那么就把问题抛给前i-1了
总容量可以放下当前这一个物品。那么，给当前物品留有相应空间下，剩下的空间内，前i-1个物品总价值加当前的物品价值的组合。
总容量放得下当前物品，但还有一种可能性，我不放当前的，那么照顾当前的物品，还不如之前的i-1个物品呢。
实际举例如下：
第一种情况。如dp[3][3]，当前物品体积是4，但是总容量只有3，根本放不下，那么dp[3][3],只能和dp[2][3]一致，都是4.
第二种情况，放得下。如dp[3][4],此时第3个体积为4，容量为4，总容量恰好能放下当前的。如果放当前的，那么留给之前的体积仅为0，一个都不放。第3个价值为5，所以总共价值为5。
如果不放该物品，那么dp[i][j]=dp[i-1][j]=4。它俩取最大值。当然是5.所以dp[3][4]=5.
总结：
注意：当前装得下时，指的是总容量装得下！！！要不装这个最大的，把问题抛给前面。要不不装大的，直接用前面的。这个思路和青蛙跳楼梯是一样的！！！！
参考文献：https://www.cnblogs.com/jiyongjia/p/13475026.html
import java.util.ArrayList;
/**
* Date: 2020/11/11 11:36
* Description:
* <p>
* 问题：现有背包。其中有四个商品。价值体积如下
* 物品编号： 1 2 3 4
* 物品体积： 2 3 4 5
* 物品价值： 3 4 5 6
* 问：如何才能保证在背包容量为8的情况下装的价值最大？
* <p>
* 步骤1：填表之后的结果：
* 0 0 0 0 0 0 0 0 0
* 0 0 3 3 3 3 3 3 3
* 0 0 3 4 4 7 7 7 7
* 0 0 3 4 5 7 8 9 9
* 0 0 3 4 5 7 8 9 10
* 步骤2：回溯
*
* @author zf
*/
public class beibao {
public static void main(String[] args) {
int[] size = new int[]{0, 2, 3, 4, 5}; //第0位放一个默认的0值,为了下边方便取size[i]就为i号物品的体积
int[] money = {0, 3, 4, 5, 6}; //第0位放一个默认的0值,为了下边方便取money[i]就为i号物品的价值
int target = 8; //指定的背包大小
//调用
int[][] ints = dpWrite(size, money, target);
ArrayList<Integer> huisu = huisu(ints, size, target);
System.out.println("您输入的背包大小是：" + target);
System.out.println("添加的物品编号是：" + huisu);
System.out.println("最大价值：" + ints[size.length - 1][target]);
}
public static int[][] dpWrite(int[] size, int[] money, int targetValue) {
//这里构造一个例如4*8的dp,行代表截止到i背包的最优组合的价值，j代表的背包的容量值
int[][] dp = new int[size.length][targetValue + 1];
//初始化第0行的值
for (int j = 0; j <= targetValue; j++) {
dp[0][j] = 0;
}
//初始化第一列的值
for (int i = 1; i < size.length; i++) {
dp[i][0] = 0;
//dp[i][1] = 0;
}
//初始化中间值i
for (int i = 1; i < size.length; i++) {
for (int j = 1; j <= targetValue; j++) {
//如果第i号背包的体积小于当前的j背包容量，就保持和dp[i-1]值相同，即没放入
if (size[i] > j) {
dp[i][j] = dp[i - 1][j];
} else {
/*即如果当前i号物品体积可以放入的话，就看预留该体积后剩余的价值在i-1号物品中的最大值加上该物品的价值和是否
是大于dp[i-1][j]的值，谁大取谁*/
dp[i][j] = Math.max(dp[i - 1][j - size[i] > 0 ? j - size[i] : 0] + money[i], dp[i - 1][j]);
}
}
}
//这样就填表完成了。剩下的就是需要回溯取出看对应某价值target的物品组合是什么
//先打印一下填的表
/*for (int i = 0; i < dp.length; i++) {
for (int j = 0; j < dp[i].length; j++) {
System.out.print(dp[i][j]+"\t");
}
System.out.println();
}*/
return dp;
}
public static ArrayList<Integer> huisu(int[][] dp, int[] size, int t) {
ArrayList<Integer> res = new ArrayList<>();
int i = dp.length - 1;
int j = t;
while (i > 0 || j > 0) {
if (dp[i][j] == dp[i - 1][j]) {
i--;
} else {
res.add(i);
j = j - size[i];
i--;
}
}
return res;
}
}
7. 有代价的最短路径
青蛙跳台阶问题。（这个和硬币找零很像）
有一个M*N的矩阵，每个网格都有一个值，求起点grid[0][0]到grid[M-1][N-1]的值的最小累加和。
这个问题很简单，构造一个相同大小的矩阵dp[M-1][N-1],首先计算第一行和第一列的值，然后其余值都为dp[i][j]=grid[i][j]+Math.min(dp[i-1][j],dp[i][j-1]),最后返回dp[M-1][N-1]即可。
public static int minPathSum(int[][] grid) {
if (grid == null || grid.length == 0 || grid[0].length == 0) {
return 0;
}
int rows = grid.length,cols = grid[0].length;
int[][] dp = new int[rows][cols];
dp[0][0] = grid[0][0];
//第一列的初始值
for (int i = 1; i < rows; i++) {
dp[i][0] = dp[i - 1][0] + grid[i][0];
}
//第一行的值
for (int j = 1;j < cols;j++){
dp[0][j] = grid[0][j] + dp[0][j-1];
}
//填写其他地方的值
for (int i = 1;i<rows;i++){
for (int j = 1;j<cols;j++){
dp[i][j] = grid[i][j] + Math.min(dp[i-1][j] , dp[i][j-1]);
}
}
return dp[rows -1][cols -1];
}