动态规划 简单 leetcode53，70，121, 64

53. 最大子序和

题目描述
评论 (639)
题解(150)New
提交记录
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例:
输入: [-2,1,-3,4,-1,2,1,-5,4],
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

思路1
O(n)复杂度的思路其实和加油站这道题一样，分段思考，假如这一段都为负数了，那么肯定不在结果的最大和子序列中

思路2
动态规划，sum表示到i为止的最大子序列和，那么和一定是Max(加上第i个数后的sum，不加第i个数重新开始计算）
res记录sum的最大值

int maxSubArray(vector<int>& nums) {
	if (nums.size() == 0)
		return NULL;
	int sum = 0;
	int res = INT_MIN;
	for (int i = 0; i < nums.size(); i++)
	{
		sum = std::max(sum + nums[i], nums[i]);
		res = std::max(res, sum);
	}
	return res;
}

---

70. 爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

示例 1：

输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。

1. 1 阶 + 1 阶
2. 2 阶
   示例 2：

输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。

1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

思路1
递归，要么爬一阶要么爬二阶
然而超时了。。。

class Solution {
public:
    int climbStairs(int n) {
        int result = 0;
        find(n,result);
        return result;
    }
    
    void find(int n, int &result) {
       if(n==1 || n==0) {
           result +=1;
          return;
        }
        if(n < 0) {
return;
}
        find(n-2, result );
        find(n-1, result);
    }
};

思路2
发现其实就是斐波那契数列。。。。

那么，第一种方法就是直接数学通式求解

第二种递归，

第三种动态规划,
第 i 阶可以由以下两种方法得到：
在第 (i−1)阶后向上爬一阶。
在第 (i−2) 阶后向上爬 2 阶。
dp[index] = dp[index - 1] + dp[index - 2]

class Solution {
public:
    int climbStairs(int n) {
        if(n==1) return 1;
        vector<int> s(n+1,-1); // 初始化n + 1 个 -1
        s[1]=1;
        s[2]=2;
        for(int i=3;i<=n;i++)
        {
            s[i]=s[i-1]+s[i-2];
        }
        return s[n];
    }
};

---

121. 买卖股票的最佳时机

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。

注意你不能在买入股票前卖出股票。

示例 1:

输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。
示例 2:

输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

思路
这道题的核心是，求数组中2个数的最大差值，被减数要在减数左边
动态规划
第i个数时的结果result = max( 第i-1前的结果result , prices[index]- min当前找到的最小被减数）

#include <iostream>
#include <vector>
#include <algorithm>
using std::vector;
class Solution {
public:

    int maxProfit(vector<int>& prices) {
        int result = 0;
        int min = INT16_MAX;
        for (int index = 0; index < prices.size(); index++) {
            min = std::min(prices[index], min);
            result = std::max(result, prices[index] - min);
        }
        return result;
    }
};

---

64. 最小路径

给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

说明：每次只能向下或者向右移动一步。

示例:

输入:
[
[1,3,1],
[1,5,1],
[4,2,1]
]
输出: 7
解释: 因为路径 1→3→1→1→1 的总和最小。

思路
典型的动态规划。。
核心就是凑出这句话
dp[x][y] = min(dp[x - 1][y], dp[x][y - 1]) + grid[x][y];
为了最快到达x，y ，最小的路径一定是从dp[x - 1][y], dp[x][y - 1]中最小的来的。

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int m = grid.size();
        int n = grid[0].size();
        vector<vector<int>> dp(m, vector<int>(n));
        
        for(int x = 0; x < m; x++) {
            for(int y = 0; y < n; y++) {
                if(x == 0 && y == 0) {
                    dp[0][0] = grid[0][0];
                } else if(x == 0) {
                    dp[x][y] = dp[x][y - 1] + grid[x][y];
                } else if(y == 0) {
                    dp[x][y] = dp[x - 1][y] + grid[x][y];
                } else {
                    dp[x][y] = min(dp[x - 1][y], dp[x][y - 1]) + grid[x][y];
                }
            }
        }
        return dp[m - 1][n - 1];
    }
};