C++算法学习心得八.动态规划算法（1）
1.动态规划理论基础
动态规划，英文：Dynamic Programming，简称DP，如果某一问题有很多重叠子问题，使用动态规划是最有效的。
动态规划中每一个状态一定是由上一个状态推导出来的，这一点就区分于贪心，贪心没有状态推导，而是从局部直接选最优的
对于动态规划问题，拆解为如下五步曲，
- 确定dp数组（dp table）以及下标的含义
- 确定递推公式
- dp数组如何初始化
- 确定遍历顺序
- 举例推导dp数组
一些情况是递推公式决定了dp数组要如何初始化
找问题的最好方式就是把dp数组打印出来，看看究竟是不是按照自己思路推导的。
做动规的题目，写代码之前一定要把状态转移在dp数组的上具体情况模拟一遍，心中有数，确定最后推出的是想要的结果
发出这样的问题之前，其实可以自己先思考这三个问题：
- 这道题目我举例推导状态转移公式了么？
- 我打印dp数组的日志了么？
- 打印出来了dp数组和我想的一样么？
2.斐波那契数（508题）
题目描述：
斐波那契数，通常用 F(n) 表示，形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是： F(0) = 0，F(1) = 1 F(n) = F(n - 1) + F(n - 2)，其中 n > 1 给你n ，请计算 F(n) 。
示例 1：
- 输入：2
- 输出：1
- 解释：F(2) = F(1) + F(0) = 1 + 0 = 1
动规五部曲：
这里我们要用一个一维dp数组来保存递归的结果
- 确定dp数组以及下标的含义
dp[i]的定义为：第i个数的斐波那契数值是dp[i]
- 确定递推公式
为什么这是一道非常简单的入门题目呢？
因为题目已经把递推公式直接给我们了：状态转移方程 dp[i] = dp[i - 1] + dp[i - 2];
- dp数组如何初始化
题目中把如何初始化也直接给我们了，如下：
dp[0] = 0;
dp[1] = 1;
- 确定遍历顺序
从递归公式dp[i] = dp[i - 1] + dp[i - 2];中可以看出，dp[i]是依赖 dp[i - 1] 和 dp[i - 2]，那么遍历的顺序一定是从前到后遍历的
- 举例推导dp数组
按照这个递推公式dp[i] = dp[i - 1] + dp[i - 2]，我们来推导一下，当N为10的时候，dp数组应该是如下的数列：
0 1 1 2 3 5 8 13 21 34 55
class Solution {
public:
int fib(int n) {
if(n<=1)return n;//
vectordp(n+1);//定义一个动态规划数组，含义是第i个斐波那契数
dp[0] = 0;//初始值设定
dp[1] = 1;
//遍历顺序，从前向后遍历
for(int i = 2;i <= n;i++){
dp[i] = dp[i - 1] + dp[i-2];//递推公式
}
return dp[n];//求第n个斐波那契数
}
}; - 时间复杂度：O(n)
- 空间复杂度：O(n)
递归法:
class Solution {
public:
int fib(int n) {
if(n < 2)return n;
return fib(n - 1) + fib(n - 2);
}
};- 时间复杂度：O(2^n)
- 空间复杂度：O(n)，算上了编程语言中实现递归的系统栈所占空间
3.爬楼梯（70题）
题目描述：
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
注意：给定 n 是一个正整数。
示例 1：
- 输入： 2
- 输出： 2
- 解释： 有两种方法可以爬到楼顶。
- 1 阶 + 1 阶
- 2 阶
动规五部曲：
定义一个一维数组来记录不同楼层的状态
- 确定dp数组以及下标的含义
dp[i]： 爬到第i层楼梯，有dp[i]种方法
dp[i] = dp[i - 1] + dp[i - 2]
不考虑dp[0]如何初始化，只初始化dp[1] = 1，dp[2] = 2，然后从i = 3开始递推，这样才符合dp[i]的定义。
确定遍历顺序
从递推公式dp[i] = dp[i - 1] + dp[i - 2];中可以看出，遍历顺序一定是从前向后遍历的
class Solution {
public:
int climbStairs(int n) {
if(n <= 1)return n; 因为下面直接对dp[2]操作了，防止空指针
vectordp(n+1);
dp[1] = 1;
dp[2] = 2;
// 注意i是从3开始的
for(int i = 3;i <= n;i++){
dp[i] = dp[i-1] + dp[i-2];
}
return dp[n];
}
}; - 时间复杂度：O(n)
- 空间复杂度：O(n)
4.使用最小花费爬楼梯 （746题）
题目描述：
数组的每个下标作为一个阶梯，第 i 个阶梯对应着一个非负数的体力花费值 cost[i]（下标从 0 开始）。
每当你爬上一个阶梯你都要花费对应的体力值，一旦支付了相应的体力值，你就可以选择向上爬一个阶梯或者爬两个阶梯。
请你找出达到楼层顶部的最低花费。在开始时，你可以选择从下标为 0 或 1 的元素作为初始阶梯。
示例 1：
- 输入：cost = [10, 15, 20]
- 输出：15
- 解释：最低花费是从 cost[1] 开始，然后走两步即可到阶梯顶，一共花费 15 。
动态规划：dp[i]的定义：到达第i台阶所花费的最少体力为dp[i]。
可以有两个途径得到dp[i]，一个是dp[i-1] 一个是dp[i-2]。
dp[i - 1] 跳到 dp[i] 需要花费 dp[i - 1] + cost[i - 1]。
dp[i - 2] 跳到 dp[i] 需要花费 dp[i - 2] + cost[i - 2]。
那么究竟是选从dp[i - 1]跳还是从dp[i - 2]跳呢？
一定是选最小的，所以dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
初始化 dp[0] = 0，dp[1] = 0，，而且dp[i]由dp[i-1]dp[i-2]推出，所以是从前到后遍历cost数组就可以了
class Solution {
public:
int minCostClimbingStairs(vector& cost) {
vectordp(cost.size()+1);//定义数组
dp[0] = 0;//初始化
dp[1] = 0;
//从i = 2从前向后遍历
for(int i = 2;i <= cost.size();i++){
dp[i] = min(dp[i - 1] + cost[i - 1],dp[i - 2] + cost[i - 2]);//递推公式
}
return dp[cost.size()];
}
}; - 时间复杂度：O(n)
- 空间复杂度：O(n)
5.不同路径 （62题）
题目描述：
一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。
问总共有多少条不同的路径？
深搜：
class Solution {
private:
int dfs(int i, int j, int m, int n) {
if (i > m || j > n) return 0; // 越界了
if (i == m && j == n) return 1; // 找到一种方法，相当于找到了叶子节点
return dfs(i + 1, j, m, n) + dfs(i, j + 1, m, n);
}
public:
int uniquePaths(int m, int n) {
return dfs(1, 1, m, n);
}
};动态规划：dp[i][j] ：表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路径。
想要求dp[i][j]，只能有两个方向来推导出来，即dp[i - 1][j] 和 dp[i][j - 1]。
此时在回顾一下 dp[i - 1][j] 表示啥，是从(0, 0)的位置到(i - 1, j)有几条路径，dp[i][j - 1]同理。
那么很自然，dp[i][j] = dp[i - 1][j] + dp[i][j - 1]，因为dp[i][j]只有这两个方向过来。
首先dp[i][0]一定都是1，因为从(0, 0)的位置到(i, 0)的路径只有一条，那么dp[0][j]也同理
递推公式dp[i][j] = dp[i - 1][j] + dp[i][j - 1]，dp[i][j]都是从其上方和左方推导而来，那么从左到右一层一层遍历就可以了。
这样就可以保证推导dp[i][j]的时候，dp[i - 1][j] 和 dp[i][j - 1]一定是有数值的
class Solution {
public:
int uniquePaths(int m, int n) {
vector>dp(m,vector(n,0));//定义dp二维数组，大小为mxn
for(int i = 0;i < m;i++)dp[i][0] = 1;//首先对最上面一行进行初始化为1
for(int j = 0;j < n;j++)dp[0][j] = 1;//对最右边的一列初始化为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];//返回值
}
}; - 时间复杂度：O(m × n)
- 空间复杂度：O(m × n)
数论方法：
在这m + n - 2 步中，一定有 m - 1 步是要向下走的，不用管什么时候向下走。
那么有几种走法呢？ 可以转化为，给你m + n - 2个不同的数，随便取m - 1个数，有几种取法。
那么这就是一个组合问题了。
class Solution {
public:
int uniquePaths(int m, int n) {
long long numerator = 1; // 分子
int denominator = m - 1; // 分母
int count = m - 1;
int t = m + n - 2;
while (count--) {
numerator *= (t--);
while (denominator != 0 && numerator % denominator == 0) {
numerator /= denominator;
denominator--;
}
}
return numerator;
}
};- 时间复杂度：O(m)
- 空间复杂度：O(1)
总结：
动态规划理论基础：动态规划是一个问题有很多子问题时候使用非常适合，其是由上一个状态推到出来的，贪心算法是由局部最优推出全局最优，动态规划五部曲，定义dp数组，初始化，遍历顺序，递推公式，打印
斐波那契数: F(n) = F(n - 1) + F(n - 2)数列需要满足这个条件，我们首先定义dp数组，第i个数的斐波那契数值是dp[i]，初始化，根据状态转移公式，我们需要知道两个初始值，dp[0] = 0，dp[1] = 1，根据状态转移公式知道遍历顺序是从前向后遍历，递推公式就是题目条件，注意细节i遍历起始和终止位置
爬楼梯：总共有N个台阶，每一次可以走1或2个台阶，问总共有几种走法能到n台阶，和斐波那契数一个道理，首先设置dp数组，dp代表爬到i层楼梯有dp[i]种方法，初始化，dp[1] = 1，dp[2] = 2，从i=3开始遍历，从前向后遍历，dp[i] = dp[i - 1] + dp[i - 2]递推公式，注意递归的边界问题
使用最小花费爬楼梯：dp[i]的定义：到达第i台阶所花费的最少体力为dp[i]，可以有两个途径得到dp[i]，一个是dp[i-1] 一个是dp[i-2]。dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2])，初始化 dp[0] = 0，dp[1] = 0，从前到后遍历，注意i 的遍历范围i=2开始还要注意终止条件。
不同路径：dp[i][j] ：表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路径定义dp数组，dp[i][j]，只能有两个方向来推导出来，即dp[i - 1][j] 和 dp[i][j - 1]，dp[i][j] = dp[i - 1][j] + dp[i][j - 1]，首先对最上面一行进行初始化为1，对最右边的一列初始化为1，我们沿着从左到右，从上到下遍历的顺序进行遍历。