前言
动态规划算法里面最有意思的一个东西之一。动态规划初学肯定会有一定晦涩难懂。如果我们去网上搜索，动态规划的资料，它一开始都是将很多的理论，导致会认为很难，但是这个东西实际上是有套路的。
动态规划的英语是Dynamic Programming(规划)，一般来说我们都简称为dp动态规划，简称DP,dp算法就是动态规划的意思
-
求解最优化问题的一种常用策略(什么是最优化问题呢？比如我们要找零钱，硬币个数最少就是最优化，最大连续子序列号，也是最优化问题。在带最字的问题求解中，就有可能用到这个动态规划去解决)
-
通常的使用套路
1.暴力递归(自顶向下，出现了重叠子问题)
2.记忆化搜索(自顶向下)
3.递推(自底向上)
一步一步优化,也就是说我们如果经验不是很足，我们很有可能不会一上来就知道用动态规划的解法去解，很有可能是一步一步的去优化，如果是一步一步的去优化，最后是如何优化到动态规划的这个做法的呢？现先只是去了解，理解不清楚也没关系，后面会反复的讲解这个问题，我们要先大概有一个初步的印象。
一般来说，我们想使用动态规划来解决最优化问题，我们最有可能想到的是暴力递归，文章后面会深刻体会到这一点，如果暴力递归不行，有很多重复的计算，出现了许多的重叠的问题。这个时候，我们可以采取记忆化搜索，什么是记忆化搜索，下面会继续学到。
采取记忆化搜索发现还是不行，效率还是不行， 或者说效率虽然提高了，但是还是有一些不必要的地方存在。这个时候需要通过递推解决。其实我们的动态规划最终就是采取**递推**的方式去做的。
上面的这些东西对刚接触的人都很抽象，不要紧，下面就能够明白这三个概念是什么意思了。我们通过下面一道例题就明白了。
案例实践
找零钱:假设有25分、20分、5分、1分的硬币，现要找给客户41分的零钱，如何办到硬币个数最少?
- 使用贪心策略得到的并非最优解(贪心得到的是5枚硬币:1个25分、3个5分、1个分)
- 如果上面的问题使用的是动态规划，这个时候我们就可以解出来最优的值也就是:2个20分、1个1分。
动态规划最适合用来解决最优化的问题，我们应该如何使用它呢？动态规划使用的熟悉了，我们就会知道:
-
首先要定义状态(状态是原问题，子问题的解)，比如定义dp(i)的含义。
-
其次设置初始状态(边界)，比如设置dp(0)的值
-
最后确定状态的转移方程,比如确定dp(i)和dp(i-1)的关系
我们最后发现动态规划算法无论咋办都是这个套路，上面的状态啥的，我们先不管，我们先解决一道题，然后再将啥是动态规划。
再使用动态规划前我们都会使用一个假设，我们是首先就来一个dp(n)是凑到n分需要最少硬币的个数
dp(41)=凑到41分的最少硬币个数
dp(20)=凑到20分的最少硬币个数
dp(n)=凑到n分钱的最少硬币个数
我们现在要求dp(41)，但是现在还求一个dp(n),那意思是不是我们现在还有求dp(1)、dp(2)、dp(3）、dp(4)这些吗？
答案是的，我们要求这些，那我们为什么要求这些呢？我们先来思考，我们假设现在要凑n分，n可能就是我们最终要的41，也有可能是100或者200都有可能。我们要凑齐n分都是从25分、20分、5分、1分的硬币里面去凑，而dp(n)是凑到最少的
硬币个数。也就是说这个已经是最优解了。我们现在要思考第一个问题，第一个硬币应该怎么去凑呢？我们的第一枚硬币应该有四种选择，假设我们的n是大于25的
假设我们的n是足够的，我们现在四枚硬币选啥都行。假设我第一枚，也就是第一次选择了25分的硬币。我们第一次选择了25分之后，现在还差多少分呢？现在还差n-25分 那现在我们考虑一个问题，d(n-25)是什么意思，它的意思是凑到n-25分之后，需要最少硬币个数.如果说我们第一次选择了25分的硬币，那么dp(n)=dp(n-25)+1,为什么是加1,因为我们选择了一枚硬币。剩下的n-25每要怎么去求，就由后面的dp(n-25)去求就行。
代码建议粘到IDE查看：
package com.lut.dynamic_programming;
public class CoinChange {
/**
* 暴力递归，它是一个自顶向下的调用，什么叫做自定向下，可以理解为较大的数，不断地
* 调用较小的数，较小的数又调用其它更小的数，这个就叫做一个自顶向下的一个调用过程
* 暴力递归就是一个自顶向下的一个调用过程，它的问题是出现了重叠子问题
* <p>
* 什么叫做重叠子问题:问题的规模最开始为n,接下来调用coins(n-5),coins(n-1)...,它
* 的规模就变小了,想当于大问题在调用它的子问题。我们下面的四个都算是n的子问题。
* <p>
* 而且这些子问题是有重复的，也就是很多的子问题进行了重复的计算。出现了重叠子问题的时候
* 我们会想到一个解决的方法就算记忆化搜索，什么叫做记忆化搜索呢？看下面的另一个方法
*/
static int coins1(int n) {
/**每一次选择硬币都有四种选择，我们要选择里面dp(n)最小的，然后dp(n)=dp(n-k)+1
* 所以现在需要通过三个Math.min选择出，四个选择中选出次数最小的，每一次选择出最
* 小后需要+1，也就是dp(n)=dp(n-k)+1。
* 需要注意的是如果硬币等于 25分 or 20分 or 5分 or 1分的时候，直接return 1就行
* 因为上面的这四种情况出现时，只需要一枚硬币，这个是递归的终止条件。
* 需要注意的是，如果硬币是19等特殊数字的时候，n-20会产生一个负数。所以为了
* 使得产生的负数直接取消比较资格，我们需要另一个边界条件。就是如果传入的n小于0
* 直接return一个特别大的数就行，也就是直接return Integer.MAX_VALUE
*
* 下面这个代码存在的问题，下面的这个代码其实是一个递归的写法，它的复杂度是2^n
* 它的调用和斐波那契数列的调用方式很像
* int fib(int n){
* if(n<=2) return 1;
* return fib(n-1)+f(n-2);
* }
* 它里面存在一些重复的计算的调用，斐波那契额数列也存在大量重复的计算
* 比如我们要求5
* fib(5) = fib(4)+fb(3)=fib(3)+fib(2)+fib(2)+f(1)=
* f(2)+f(1)+f(2)+f(2)+f(1)=5
*
* f(4) = fib(3)+f(2)=fib(2)+fib(1)+fib(2)=3
*
* f(10) = f(9)+f(8)=f(8)+f(7)+f(7)+f(6)=f(7)+f(6)+f(6)+f(5)+f(6)+f(5)+f(5)+f(4)=
* f(6)+f(5)+f(5)+f(4)+f(5)+f(4)+f(5)+f(5)+f(4)+f(5)+f(5)+f(4)=
* f(5)+f(4)+f(5)+f(5)+f(4)+f(5)+f(4)+f(5)+f(5)+f(4)+f(5)+f(5)+f(4)=40+15=55
*而我们的这个找硬币的方法同样也存在大量重复的计算
* 假设我们现在传入的n是6，也就是coins(6)
* coins(6)->coins(5)+coins(1)->coins(0)+coins(4)+coins(1)->coins(1)->coins(0)
* 如果n的传入的数字非常大，它存在很多重复的情况。
*
* 因为暴力递归存在很多重复的情况，我们现在要考虑如何去优化它呢。
* 我们刚一开始想使用动态规划，一上来就会想到暴力递归，下面的方法就算暴力递归
*/
if (n < 1) return Integer.MAX_VALUE;
if (n == 25 || n == 20 || n == 5 || n == 1) return 1;
int min1 = Math.min(coins1(n - 25), coins1(n - 20));
int min2 = Math.min(coins1(n - 5), coins1(n - 1));
return Math.min(min1, min2) + 1;
}
static int fib(int n) {
if (n <= 2) return 1;
return fib(n - 1) + fib(n - 2);
}
/**
* 记忆化搜索(自顶向下的调用)
* 记忆化搜索就是把曾经算过的那个值，曾经求解过的那个子问题的解给存起来，这个就叫做记忆化
* 其实它就是缓存，我们可以考虑使用数组来解决这个事情。所谓记忆化就是把出现了的值放到内存
* 里面去
* <p>
* 我们应该如何去实现呢？我们先要引入一个数组，因为是动态思想，这个数组，一般我们把它命名
* dp,问题是这个数组是干嘛用的，这个数组的作用是:假如我们调用了coins(6),它算出来的值是凑
* 齐6分至少要花费最少硬币的个数是多少。一旦我们算出来的值是4枚硬币，这个时候我们就会把
* dp[16]赋值为4。所以dp数组的意思是，如果是dp[16]就代表要凑够16分的话，它所需的最下硬币
* 个数我们把它存起来。就是这么一个道理。
* dp[n]就是凑够n分需要的最小硬币个数。为了能够直接dp[n]所以我们在给这个数组申请内存的时候
* 传入的长度是n+1,因为数组的索引是从0开始的。 长度只有是n+1，才能够直接放n
* <p>
* 这个方法还是存在递归调用，但是每一个dp[n]=只会进入一次递归，有了值就不会再次进行递归取值
* 操作。
* <p>
* 记忆化搜索依然是自定向下调用，还是一个较大的值调用一个较小的值。但是性能相比暴力搜索有较大的
* 提升。
*/
static int coins2(int n) {
if (n < 1) return -1;
/**
* 因为传入n时如果n为19这样的特殊元素，可能会出现19-25=-6这样的数据，我
* 们可以进一步对其进行做处理
*/
int[] dp = new int[n + 1];
int[] faces = {1, 5, 20, 25};
for (int face : faces) {
if (n < face) break;
dp[face] = 1;
}
return coins2(n, dp);
}
static int coins2(int n, int[] dp) {
if (n < 1) return Integer.MAX_VALUE;
// if (n == 1 || n == 5 || n == 20 || n == 25) {//初始化操作
// dp[n] = 1;
// }
if (dp[n] == 0) {
int min1 = Math.min(coins2(n - 25, dp), coins2(n - 20, dp));
int min2 = Math.min(coins2(n - 5, dp), coins2(n - 1, dp));
dp[n] = Math.min(min1, min2) + 1;
} else {
return dp[n];
}
return dp[n];
}
/**
* 上面了做了记忆化搜索，动态规划的最后一步叫做递推。我们只有写到递推这一步才能叫做
* 真正的动态规划，递推和前面的暴力递归和记忆化搜索都是不一样的，它是自底向上的。前
* 面的两步仅仅是前奏，我们刚开始发现能够暴力递归，然后我们发现能够使用记忆化搜索来
* 优化，但是使用了记忆化搜索优化之后，发现还可以优化，那就算什么优化呢？就是递推。
* 通过递推的形式，递推说的广泛一点，就是大家认为的非递归，也就是递推，当然有人也把
* 叫做迭代，但是这里叫做递推比较好。就是一步一步的往前面推，这个叫做递推。
*/
/**
* 递推(自底向上)
* 我们发现前面记忆化搜索的时候，定义了一个dp数组，用于记录搜索过的值。
* 比如我们计算完了凑够n分最少要凑够多少枚硬币计算出来了，这个时候我们
* 就将这个数放在这个数组里面去，dp(n)=凑足n分需要的最少的硬币数目。
* 我们前面是由大到小的调用，从41到往下掉 16 21 26 40 然后这四个
* 数字右会分成4个叉往下掉，一直往下，得到的dp[n]的值是先把d(n-25)的值
* dp(n-20),dp(n-5),dp(n-1)的值算出来。只有将这四个值都算出来了，最终
* 才能知道这个n的值是多少。
* 说白了，现在我们要求凑够41分的硬币个数，要先求出凑够16的硬币最小个数
* 凑够21分的硬币最小个数，凑够36分和凑够40分的最小硬币个数。也就是我们要凑够比较
* 大的硬币的分数，必然要先求出凑够哪些比较小的分需要的硬币个数。小的算出来了，才有办法
* 求出比较大的，所以我们完全有理由相信我们可以由小算到大，因为本来这个式子就可以看得出来
* 肯定要先算出小的。才能算出这个n比较大的
* 所以我们这个dp[]这个数组完全可以由小往大的方向去算。我们通过下面的for循环来测试看
* 这个结果能不能行，for(int i = 1; i <= n; i++){ dp[i] = ;}我们可以先求dp[1]一直到
* dp[n]就可以了。这样就是由小到大的去算。那么我们的方法的返回值应该写啥呢？这个方法我们直接
* 返回一个dp[n]就行了。问题是dp[i]我们要咋求呢？
* 我们知道求dp[i]我们肯定是在dp[i-25],dp[i-20],dp[i-5],dp[i-1]中最小的值拿出来再
* 加1，也就是反着通过不断地i+1、i+5,i+20,i+25来达到i+k=n 问题是我们的i是从1开始的，1-25，
* 1-20...这些数据肯定是不合理的，i等于1的时候1-1好像
* 也没有什么意义。这个时候我们就得去判断，首先来一个int min = Integer.Math_VALUE;然后去判断
* 哪一个合适也就是。现在我们就直接通过比较直接获取最大得值，因为19-25小于0会导致索引越界。所以
* 我们需要在前面加上一个越界判断条件。
*/
static int coins3(int n) {
if (n < 1) return -1;
int[] dp = new int[n + 1];
for (int i = 1; i <= n; i++) {
// int min = Integer.MAX_VALUE;
// if (i >= 1) min = Math.min(dp[i - 1], min);
int min = dp[i - 1];
if (i >= 5) min = Math.min(dp[i - 5], min);
if (i >= 20) min = Math.min(dp[i - 20], min);
if (i >= 25) min = Math.min(dp[i - 25], min);
dp[i] = min + 1;
}
return dp[n];
}
/**
* 为啥这个叫做动态规划？未啥叫做动态规划，它的具体含义是啥，我们先不去了解
* 先通过做题去领悟。
*
* 我们需要知道的是，我们现在不断地给代码做优化，现在上面代码的时间复杂度是o(n)
*/
/**
* 思考题:请输出找零钱的具体方案(最少硬币，具体是使用了哪些面值的硬币)
* 我们应该怎么做呢？我们现在就在递推代码来进行实现。
* 我们现在要凑够n分，它具体使用哪些面值。
* <p>
* 为了充分理解，我们还是先写成前面的代码，
* if (n < 1) return -1;
* int[] dp = new int[n + 1];
* for (int i = 1; i <= n; i++) {
* int min = Integer.MAX_VALUE;
* if (i >= 1) min = Math.min(dp[i - 1], min);
* if (i >= 5) min = Math.min(dp[i - 5], min);
* if (i >= 20) min = Math.min(dp[i - 20], min);
* if (i >= 25) min = Math.min(dp[i - 25], min);
* dp[i] = min + 1;
* }
* return dp[n];
* 首先我们dp[i]是指的凑够i分钱，最少需要多少枚硬币。所以我们就先考虑
* 凑够i-1,i-5,i-20,i-25看一下这些凑够这些分数，哪一个硬币数是最小的
* 把它们最小的值挑出来然后+1，这个1就是指的是最后一次选择了一枚硬币，它
* 可能是1分、5分、20分、25分。
* 我们的关键点就是在进入了那个if判断就可以知道它最后一次选择了哪一枚，
* 举个例子，我们首先得搞清楚，min这个东西肯定是这四个当中的最小值。如果
* 我们这一轮比较中发现dp[i-1],dp[i-5],dp[i-20],dp[i-25]中dp[i-20]是
* 最小的，它是这四个当中最小的，那毫无疑问这个min就算dp[i-20],这就意味着
* 你这一次选择了一枚20分的，也就是最后一次选择了一枚20分。意味着这一次min+1
* 这个1代表，选择了一枚20分的硬币。
* 只有我们这次选的是20,才会去使用dp[i-20]这个值,所以答案就出来了，我们要
* 想知道这一次选择了那一枚，我们只需要看一下这个min它来自于那个if判断，如果我们
* 这个min来自于if (i >= 20) min = Math.min(dp[i - 20], min),也就是一枚20
* 分的，如果min来自于if (i >= 25) min = Math.min(dp[i - 25], min)说明选择
* 的是一枚25分的，我们可以去记录一下。
* 应该如何去记录呢？因为我们这里是一个for循环，肯定是选择了很多次，所以我们可
* 以考虑这么做，int[] faces = new int[dp.length];
* 这个faces[i]是什么意思呢？它的意思代表+1选择了哪一枚，比如假如我们的min是选择
* 的dp[i-20],说白了这一次的加1,代表选择了20分的，才会去考虑i-20凑够i-20需要多少硬币
* 所以这一次选20的话，这个faces[i]=20，它存下来有啥作用呢？我们可以充分利用这个东西了，
* 我们现在改写一下原来的代码
* for(int i=1; i <= n;i++){
* if(n<1) return -1;
* int[] dp = new int[n+1];
* int[] faces = new int[dp.length];
* for(int i=1;i <= n;i++){
* int min = Integer.MAX_VALUE;
* if(i >= 1 && dp[i-1] < min){
* min = dp[i-1];
* faces[i] = 1;
* }
* if(i >= 5 && dp[i-5] < min){
* min = dp[i-5];
* faces[i] = 5;
* }
* if(i >= 20 && dp[i-20] <min){
* min = dp[i-20];
* faces[i] = 20;
* }
* if(i >= 25 && dp[i-25] <min){
* min = dp[i-25];
* faces[i] = 25;
* }
* }
* }
* 改写后的代码，最开始min=Integer.MAX_VALUE。当我们如果发现这个时候i>=1的
* 并且dp[i-1]又是比这个min小,说白了我们发现一个更小的值。所以我们应该把这个值给存起来
* 一旦最小值使用了这个方案，也就是说，这一次，我们是选择了一枚一分的，如果i>=5而且比
* dp[i-5]<min，也就是min小于刚刚算的那个最小值还要小，那说明现在发现的最小值min=dp[i-5],
* 如果我们这一次使用的最小值使用的是dp[i-5]说明这一次要选择必然是5分的。我们现在已经求完
* 前面的，现在我们又发现i>=20，并且dp[i-20]<min,那么我们就让最小值是min=dp[i-20],一旦
* 我们采取的是让min作为我们的最小值，意味着我们最后一次一定是选择的一枚20分的硬币。依次类推
* 如果我们发现dp[i-25]还要更小，我们最小值就采取它，说白了这一次选择的硬币必然是25分的。我们
* 才会考虑i-25分的最小值是多少。
* 理解这个问题的关键就在faces[i]的存储，这个答案就求存来了，这样我们就能够知道每一次
* 拿到的硬币数是谁。求出这个东西之后有啥用，肯定是利用这个faces[]数组去搞事情
*/
static int coins4(int n) {
if (n < 1) return -1;
int[] dp = new int[n + 1];
int[] faces = new int[dp.length];
for (int i = 1; i <= n; i++) {
int min = Integer.MAX_VALUE;
if (i >= 1 && dp[i - 1] < min) {
min = dp[i - 1];
faces[i] = 1;
}
if (i >= 5 && dp[i - 5] < min) {
min = dp[i - 5];
faces[i] = 5;
}
if (i >= 20 && dp[i - 20] < min) {
min = dp[i - 20];
faces[i] = 20;
}
if (i >= 25 && dp[i - 25] < min) {
min = dp[i - 25];
faces[i] = 25;
}
dp[i] = min + 1;
print(faces, i, dp);
}
// print(faces,n);
return dp[n];
}
private static void print(int[] faces, int n, int[] dp) {
System.out.println("凑齐" + n + "分至少需要" + dp[n] + "硬币");
while (n > 0) {
System.out.println("需要" + faces[n] + "分1枚");
n -= faces[n];
}
}
/**
* 这里我们没有具体了解啥是动态规划，只是先理解啥是暴力递归，记忆化搜索，递推
* 最后我们打印了一下这个具体的面值组成。
* <p>
* 下面我们需要给这个找零钱写一个通用的实现，就是可以由别人传面值进来，我们之前
* 的面值都是固定死了的，我们可以搞一个由别人传面值进来，所以这里可以咋做呢？
*/
static int coins5(int n,int[] faces) {
if(n < 1 || faces == null || faces.length == 0) return -1;
int[] dp = new int[n+1];
for (int i = 1; i <= n; i++){
int min = Integer.MAX_VALUE;
for (int face : faces) {
if(i < face || dp[i-face]<0) continue;
min = Math.min(dp[i-face],min);
}
if(min == Integer.MAX_VALUE){
dp[i] = -1;
}else{
dp[i] = min + 1;
}
}
return dp[n];
}
public static void main(String[] args) {
System.out.println(coins5(41,new int[]{5,20,25}));
}
}
难点：
我们现在要思考的是，我们的第一次可能不是选25分，也有可能选择的是20分，如果我们选择了20分的硬币的话
那么dp(n) = dp(n-20)+1。如果第一次选择了5分的硬币，那么dp(n)=dp(n-5)+1。如果第一次选择了1分的
硬币，那么dp(n)=dp(n-1)+1。但是这四种情况都是有可能发生的，因为我第一次选哪个硬币是不确定的。
我们现在要干嘛呢？要求的是dp(n)的最小硬币数。
其实就是这四个值当中的最小值。也就是dp(n) = min{dp(n-25),dp(n-20),dp(n-5),dp(n-1)}+1
所以我们就是从四个中挑出最小的那个。然后+1
我们在四个情况中取出最小的，就算所有中最小的，所以动态规划它能求出最优解，为啥它能求出最优解，是因为
它把所有的情况都考虑到了，为啥贪心不能呢？因为贪心它只看眼前的局部利益，这个就贪心算法的一个问题所在
⚪假设dp(n)是凑到n分需要的最少的硬币个数
⚪如果第一次选择了25分的硬币，那么dp(n)=dp(n-25)+1
⚪如果第一次选择了20分的硬币，那么dp(n)=dp(n-20)+1
⚪如果第一次选择了5分的硬币，那么dp(n)=dp(n-5)+1
⚪如果第一次选择了1分的硬币，那么dp(n)=dp(n-1)+1
⚪所以dp(n)=min{dp(n-25),dp(n-20),dp(n-5),dp(n-1)}+1
分析找零钱案例：
学习完了找零钱，它的解法就是动态规划，现在我们就来学习到底啥是动态规划，我们要学习动态规划，有一个前提我们要知道找零钱最开始是咋做的，我们一开始是进行暴力递归。我们要凑够n分，就看n-1,n-5,n-20,n-25从它们
四个中挑一个最小的，然后再来一个加1。后来我们发现递归的很多子问题中，有很多重复，我们就使用了一个记忆化搜索，但是这个记忆化搜索，仅仅是搞
了一个数组，里面记录着凑够某个面值有的最小硬币个数，就是使用这个dp这个数组，去记录。但是这个记忆化搜索依旧是从上往下的调用的，依然还存在着递归调用。后面我们发现，完全可以通过一个递推的形式，就是自底向上，先求出较小的值，进而再往上推，推出值比较大的，也就是我们发现我们的这个dp数组完全可以从dp[1]开始，到dp[2],dp[3],dp[4],d[5]一直往上面求，所以我们dp[i]的i一直在增
长，所以的话是由小推到大，所以这样的话，我们直接把递归调用给省略掉了。这个过程就可以理解为在执行动态规划的一个过程。
动态规划它究竟是个什么呢？我们来回顾一下，它有一些抽象，但是不难理解。动态规划是求解最优化问题的一种常用的策略，比如我们讲到找零钱兑换，它就是看最少硬币个数多少，最少这个就是一个最优化问题，它通常的套路是啥呢？
我们先来一个暴力递归，然后接下来发现有重复的，这个时候我们来一个记忆化搜索，前面两种都是递归，都是自顶向下的我们后来发现可以自底向上，也就是从小到大使用记忆化搜索，可以去推出这个值。
为啥这个就叫做动态规划呢？这个时候我们就可以利用比较专业的术语来说这一个问题。动态规划中的"动态"可以理解为是"可以变化的状态"
-
定义状态(状态是原问题、子问题的解)
比如dp[i]的定义 -
设置初始状态(边界)
比如设置dp[0]的值
-
确定状态转移方程
比如确定dp(i)和dp(i-1的关系)
动态规划的常规步骤，第一个步骤定义状态，什么是状态，状态就是原问题，子问题的解，比如定义一下dp(i)的含义，这个就叫做定义状态，举个例子，我们之前在讲零钱兑换的时候，我们定义了一个东西——dp(n),dp(n)就是凑到n分最少的
硬币个数，如果我们这里写一个dp(41)就是凑够41需要的最少硬币个数。如果是dp(4)那就是凑够4分所需的最少硬币个数所以我们这里的dp(n)就代表定义状态，这个定义状态的意思就算要得到这个解，因为这个dp(n)就是我们最终想要得到的
一个解，到时候n是41，dp(41)就是我们最终要的这个解。 所以动态规划里面定义状态，这个状态一般来说就是原问题的解，也是子问题的解，这句话啥意思呢?我们现在虽然定义了个dp(n),确实是我们最重要的一个解，当我们的这个n=41的时候，它就是我们想要的解。当规模更小了就变成子问题了，这个时候dp(n-25)就是一个子问题的解，就算凑够n-25分需要的最少硬币数，它就算子问题的解。动态规划一上来就是定义规划，我们定义的这个状态，一般就是这个问题最终的解，也是子问题要的一个解。
定义完这个状态的时候我们接下来要设置一些边界条件，也就是初始状态，比如设置一下dp(0)的值，当然不一定是dp[0]，它有可能是dp(1),dp(2),dp(3)这些都是初始值，这些就是设置一些初始状态，那些值是可以直接确定的，哪些子问题的解我们是可以直接马上确定的，我们就给它马上设置一个初始值。
比如以找零钱的代码为例子，我们先搞了一个dp[]数组，也就是状态数组，我们做了一个啥初始化，dp[face]=1，说白了凑够1肯定1枚，凑够5、20、25的话，肯定也是一枚，凑够5和凑够25的话，最少硬币就是一枚。像这种就是初始值，所以初始值就是这个。但是有很多问题里面，就是直接初始化dp[0],这个也叫做边界条件。这个根据条件而定，不同题目的边界条件是不一样的，这个dp[i]的状态定义出来了，我们把这个解是怎样的一个形式定义出来了，初始值也有了，也就是边界条件也有了，接下来就要开始递推了。
开始递推，也就是从dp(0)一直推到dp(i),一直往后推，这个推的过程，专业来说，叫做确定状态转移方程，为啥叫做状态转移方程，前面我们清楚的知道了，dp[i]代表状态，我们会将dp(i)从小推到大，说白了先求出dp(1)的值，然后推出dp(2)的值是什么就相当于从1这个状态转移到2这个状态，我们现在从小求到大，就相当于由以前的状态要推出一个新的状态，由旧的状态，要推导出一个新的状态，所以这个专业来讲，叫做状态转移方程。
简单来说，状态转移方程，就是确定我们dp(i)和dp(i-1)的关系，就是我们知道dp(i-1)怎么知道dp(i),一旦知道了这dp(i)怎么推出dp(i+1)，这个叫做状态转移方程，也就是确定哪个递推式，确定那个递推关系。这个就是动态规划的三大步骤。
我们会影响深刻的，定义完状态，有一些初始状态我们要去设置一下，也就是边界条件，这个时候我们就需要一个状态转移方程，看一下然后知道这个dp(i-1)怎么推导出dp(i)呢？怎么由dp(i)推导出dp(i+1)，这个就叫做状态转移方程。
动态规划的一个解释:
Dynamic Programming is a method for solving a complex problem by breaking it down into a collection of simpler subProblem,solving each of those subProblems just once,and storing theirsolutions
也就是说动态规划，就是把原问题分解成一系列的更简单的子问题，并且把每一个子问题只解决一次，并且把它的值给存储。
⚪将复杂的问题拆解成若干个简单的子问题
⚪每个子问题仅仅解决一次，并保存它们的解
⚪最后再推导出原问题的解
⚪可以用动态规划来解决的问题，通常具备2个特点
⚪最优子结构(最优化原理):通过求解子问题的最优解，可以获得原问题的最优解(如果符合这个特点，这就叫做最优子结构)
⚪无后效性(动态规划不仅仅要有最优化子结构，还得满足无后效性，必须满足两个条件才能通过动态规划来解决)
- 某阶段的状态一旦确定，则此 后过程的演变不再受此前各状态的决策影响(未来与过去无关)
- 在推导后面阶段的状态时;只关系前面阶段的具体状态值，不关心这个状态是怎么一步一步推导出来的
无后效性(举例)
现在有一个5*5的一个格子,从起点(0,0)走到终点(4,4)一共有多少种走法？只能向右、向下走。
如果我们要使用动态规划解决这个问题，我们首先第一件事就是去定义状态，这个时候我们发现我们现在要定义的状态是2维的了，不再是1维的了，之前只有dp(i),现在我们定义了一个dp(i,j),dp(i,j)的意思是从(0,0)走到(i,j)的走法，也就是dp(i,j),也就是dp(4,4),这个问题既是子问题的解，又是原问题的解。那么初始值是什么，我们定义完状态肯定有一个初始状态的值，我们现在要看一下那一些是初始值，dp(0,0)是1还是0，因为从自己走到自己是1种走法，但是我们关注的重点不是这个，除了dp(0,0),还有哪些值是可以确定的，其实还有dp(i,0)和dp(0,j) 这几种状态都是只有一种走法，所以dp(i,0)=dp(0,j)=1我们现在把水平方向用i表示，我们把竖直方向定义为j。现在问题来了，状态转移方程应该怎么写。
- 假设dp(i,j)是从(0,0)走到(i,j)的走法
- dp(i,0)=dp(0,j)=1
- dp(i,j)=dp(i,j-1)+dp(i-1,j)
(状态转移方程怎么写，也就是我们现在要求(i,j)要从哪个点推导过来，也就是可以从哪些地方走过来，只能向下向右走。它只能从(i-1,j)往右走，或者从(j,j-1)往下走。所以dp(i,j)=dp(i,j-1)+dp(i-1,j),前面的公式代表着，从(0,0)到(i,j)的走法，
说白了就是dp(i,j-1)和dp(i-1,j)的走法之和。无后效性)
无后效性,推导dp(i,j)时只需要用到dp(i,j-1)、dp(i-1,j)的值,不需要关心dp(i,j-1)、dp(i-1,j)的值是怎么求出来的，我们只需要有多少种走法，并不关心如何走的。而且也不影响使用这个值去推导别的值
上面只是解释了什么是无后效性，现在我们要去看一个相反的情况，就是什么是有后效性，只有理解了什么是有后效性，才能去理解什么是**无后效性**，这个问题比较抽象，我们先来看一个有后效性的例子。还是前面的5*5的一个格子，不过现在可以向左、向右、向上、向下走，并且同一个格子不能走两次，这个问题就有后效性了。
