leetcode数组刷题（八）——动态规划
动态规划最重要的问题是写出动态规划方程，根据动态规划方程分情况写出转移代码，最后的结果就是要求的量。
62、不同路径
一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。
问总共有多少条不同的路径？
class Solution {
public:
int uniquePaths(int m, int n) {
if(m==0||n==0) return 0;
auto dp = vector<vector <int> > (m, vector <int> (n));//dp表示路径数
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];
}
};
63、不同路径 II
一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。
现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？
网格中的障碍物和空位置分别用 1 和 0 来表示。
和官方代码不太一样，官方压缩成一维数组不太看得懂，自己沿用I的思路，区别就是要判断是否有障碍物，其中可能要理解一下的地方，就是在首行或者首列判断时，其实如果动态计算时，该元素没有值，也就没有这条路径了。
class Solution {
public:
int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
int m = obstacleGrid.size();
int n = obstacleGrid[0].size();
if(m==0||n==0) return 0;
auto dp = vector<vector <int> > (m, vector <int> (n));//dp表示路径数
for (int i = 0; i < m && obstacleGrid[i][0]==0; i++) {
dp[i][0] = 1;
}
for (int j = 0; j < n && obstacleGrid[0][j]==0; j++) {
dp[0][j] = 1;
}
for (int i = 1; i < m; i++) {
for (int j = 1; j < n; j++) {
if(obstacleGrid[i][j]==1){
dp[i][j] = 0;
continue;
}
else dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
}
}
return dp[m-1][n-1];
}
};
64、最小路径和
给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
说明：每次只能向下或者向右移动一步。
继续沿用不同路径时的计算思路，区别是这题要计算路径和，所以元素不是赋值1，而是要加上路径和的计算，基本动态方程就是上一个路径的最小值加上当前方格内的元素值。
class Solution {
public:
int minPathSum(vector<vector<int>>& grid) {
if (grid.size() == 0 || grid[0].size() == 0) {
return 0;
}
int rows = grid.size(), columns = grid[0].size();
auto dp = vector<vector <int> > (rows, vector <int> (columns));
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 < columns; j++) {
dp[0][j] = dp[0][j - 1] + grid[0][j];
}
for (int i = 1; i < rows; i++) {
for (int j = 1; j < columns; j++) {
dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
}
}
return dp[rows - 1][columns - 1];
}
};
70、爬楼梯
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
class Solution {
public:
/* 动态规划五部曲：
* 1.确定dp[i]的下标以及dp值的含义： 爬到第i层楼梯，有dp[i]种方法；
* 2.确定动态规划的递推公式：dp[i] = dp[i-1] + dp[i-2];
* 3.dp数组的初始化：因为提示中，1<=n<=45 所以初始化值，dp[1] = 1, dp[2] = 2;
* 4.确定遍历顺序：分析递推公式可知当前值依赖前两个值来确定，所以递推顺序应该是从前往后；
* 5.打印dp数组看自己写的对不对；
*/
int climbStairs(int n) {
if (n <= 1) return n;
/* 定义dp数组 */
vector<int> dp(n+1);//0~n
/* 初始化dp数组 */
dp[0] = 1;
dp[1] = 1;
/* 从前往后遍历 */
for(int i = 2; i <= n; i++) {
dp[i] = dp[i-1] + dp[i-2];
}
return dp[n];
}
};
121、买卖股票的最佳时机
给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。
虽然官方也给了暴力解法，但是计算超时。
class Solution {
public:
int maxProfit(vector<int>& prices) {
int n = (int)prices.size(), ans = 0;
for (int i = 0; i < n; ++i){
for (int j = i + 1; j < n; ++j) {
ans = max(ans, prices[j] - prices[i]);
}
}
return ans;
}
};
官方的第二种解法是遍历，感觉和动态规划也是一个意思，就是从头到尾走一遍，所以写的遍历的代码如下，重点问题就是找到最低价，并且判断后续每一天的最高差价，临界条件就是第一天的最低价就是当天的价格。
class Solution {
public:
int maxProfit(vector<int>& prices) {
vector<int> dp(prices.size());
dp[0] = prices[0];
int M = 0;
for(int i=1;i<prices.size();++i){
dp[i] = min(dp[i-1],prices[i]);
M = max(M,(prices[i]-dp[i]));
}
return M;
}
};
122、买卖股票的最佳时机 II
给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。
在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。
返回 你能获得的 最大 利润 。
采用动态规划的思想，主要问题依旧是写出动态方程和临界值，这题的没有想到的是返回值上面，同时要考虑到不同买同卖。
class Solution {
public:
int maxProfit(vector<int>& prices) {
int n = prices.size();
auto dp = vector<vector <int> > (n, vector <int> (2));
//0无股票1有股票
dp[0][0] = 0;dp[0][1] = -prices[0];
for(int i =1;i<n;++i){
dp[i][0] = max(dp[i-1][0],(dp[i-1][1]+prices[i]));
dp[i][1] = max(dp[i-1][1],(dp[i-1][0]-prices[i]));
}
return dp[n-1][0];//这一点没想到，应该是不持有股票收益才高，所以不需要考虑1
}
};
第二种算法更简单，感觉和官方说的贪心算法一个意思，直白一点就是只要把所有的正收益都算上，就是卖股票的最大收益。
class Solution {
public:
int maxProfit(vector<int>& prices) {
int sum = 0;
for(int i=1;i<prices.size();++i){
sum = sum + max(0,(prices[i]-prices[i-1]));
}
return sum;
}
};
123、买卖股票的最佳时机 III
给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
沿用设置dp的模板方案，写出了以下的代码，分多步是因为要经历买卖才能知道下一次的初始值，不然初始值会设置错误，一共分为五个状态，但是性能不行，毕竟多循环加上内存：
class Solution {
public:
int maxProfit(vector<int>& prices) {
int n =prices.size();
auto dp = vector<vector<int>> (n,vector<int>(5));//收益
//0未买1买一2卖一3买二4卖二
dp[0][0] = 0;dp[0][1] = -prices[0];
for(int i=1;i<n;++i){
dp[i][0] = dp[i-1][0];
dp[i][1] = max(dp[i-1][1],(dp[i-1][0]-prices[i]));
dp[i][2] = dp[i-1][1]+prices[i];
}
for(int i=2;i<n;++i){
dp[i][2] = max(dp[i-1][2],(dp[i-1][1]+prices[i]));
dp[i][3] = dp[i-1][2]-prices[i];
}
for(int i=3;i<n;++i){
dp[i][3] = max(dp[i-1][3],(dp[i-1][2]-prices[i]));
dp[i][4] = dp[i-1][3]+prices[i];
}
for(int i=4;i<n;++i){
dp[i][4] = max(dp[i-1][4],(dp[i-1][3]+prices[i]));
}
return max(max(dp[n-1][2],dp[n-1][4]),0);
}
};
借鉴了一下官方的解题思路，简化了一下一开始写的代码，得出了以下形式，但是还是二元矩阵，内存上还是大一点的，但是想了一下之前初始值不对可能自己想的有点多，初始值都设置成一样的概念，同时返回值也只返回二次卖出后的收入，虽然依旧不是很理解吧hhh：
class Solution {
public:
int maxProfit(vector<int>& prices) {
int n =prices.size();
auto dp = vector<vector<int>> (n,vector<int>(5));//收益
//0未买1买一2卖一3买二4卖二
dp[0][0] = 0;dp[0][1] = -prices[0];
dp[0][2] = 0;dp[0][3] = -prices[0];dp[0][4] = 0;
for(int i=1;i<n;++i){
dp[i][0] = dp[i-1][0];
dp[i][1] = max(dp[i-1][1],(dp[i-1][0]-prices[i]));
dp[i][2] = max(dp[i-1][2],(dp[i-1][1]+prices[i]));
dp[i][3] = max(dp[i-1][3],(dp[i-1][2]-prices[i]));
dp[i][4] = max(dp[i-1][4],(dp[i-1][3]+prices[i]));
}
//return max(dp[n-1][2],dp[n-1][4]);
return dp[n-1][4];
}
};
188、买卖股票的最佳时机 IV
给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
沿用三的思路，区别就是找买和卖，也就是奇数和偶数的区别，然后分类讨论就行：
class Solution {
public:
int maxProfit(int k, vector<int>& prices) {
int n =prices.size();
auto dp = vector<vector<int>> (n,vector<int>(2*k+1));//收益
for(int i=0;i<2*k+1;++i){
if(i%2==0) dp[0][i] = 0;
else dp[0][i] = -prices[0];
}
for(int i=1;i<n;++i){
dp[i][0] = dp[i-1][0];
for(int j=1;j<2*k+1;++j){
if(j%2!=0) dp[i][j] = max(dp[i-1][j],(dp[i-1][j-1]-prices[i]));
else dp[i][j] = max(dp[i-1][j],(dp[i-1][j-1]+prices[i]));
}
}
return dp[n-1][2*k];
}
};
309、最佳买卖股票时机含冷冻期
给定一个整数数组prices，其中第 prices[i] 表示第 i 天的股票价格 。
设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:
卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
一开始没有想出来状态设置成什么，然后看了一下解析大概明白了，一般题目中的状态就是提示，想办法把状态之间的转移找出来就可以了。
class Solution {
public:
int maxProfit(vector<int>& prices) {
int n = prices.size();
auto dp = vector<vector<int>> (n,vector<int>(3));
if(n==0 || n==1) return 0;
//0有股票1今天卖2昨天卖不可买
dp[0][0] = -prices[0];
dp[0][1] = 0;
dp[0][2] = 0;
for(int i=1;i<n;++i){
dp[i][0] = max(dp[i-1][0],dp[i-1][2]-prices[i]);
dp[i][1] = dp[i-1][0]+prices[i];
dp[i][2] = max(dp[i-1][2],dp[i-1][1]);
}
return max(dp[n-1][1],dp[n-1][2]);
}
};
714、买卖股票的最佳时机含手续费
给定一个整数数组 prices，其中 prices[i]表示第 i 天的股票价格 ；整数 fee 代表了交易股票的手续费用。
你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。
返回获得利润的最大值。
注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。
在122买卖股票的最佳时机基础上加上一个手续费即可：
class Solution {
public:
int maxProfit(vector<int>& prices, int fee) {
int n = prices.size();
auto dp = vector<vector<int>> (n,vector<int>(2));
//0无股票1有股票
dp[0][0] = 0;dp[0][1] = -prices[0];
for(int i =1;i<n;++i){
dp[i][0] = max(dp[i-1][0],(dp[i-1][1]+prices[i]-fee));
dp[i][1] = max(dp[i-1][1],(dp[i-1][0]-prices[i]));
}
return dp[n-1][0];
}
};
剑指 Offer 63、股票的最大利润
假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少？
同121买卖股票的最佳时机，不作另外说明
1206
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
