【leetcode】dp---简单（1）53. 最大子序和_序列和（2）70. 爬楼梯（3）121. 买卖股票的最佳时机_序列两数差_股票1

本文链接：https://blog.csdn.net/LanXinYue98/article/details/107876494

53、给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例:

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

dp[i] = max(dp[i - 1] + nums[i] , nums[i]);

// dp[i]： 以i为结尾的序列和的最大值. i:数组下标
// 状态转移 ：1) i归入前面的序列; 2) i独立开辟新的序列。
// dp[i] = max(dp[i - 1] + nums[i] , nums[i]); 
vector<int> dp;

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        dp.resize(nums.size(), 0);
        int ans = nums[0];
        dp[0] = nums[0];
        for(int i = 1; i < nums.size(); i++){
            dp[i] = max(dp[i - 1] + nums[i], nums[i]);
            ans = max(ans, dp[i]);
        }
        return ans;
    }
};

结果：

执行用时：4 ms, 在所有 C++ 提交中击败了97.42% 的用户

内存消耗：7.2 MB, 在所有 C++ 提交中击败了18.39% 的用户

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

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

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

示例 1：

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

dp[i] = dp[i-1] + dp[i-2]

// dp[i]:爬到第i阶梯的方法。i:阶梯数
// 状态转移：1)前一层楼梯走一步，2)前两层楼梯走两步
// dp[i] = dp[i-1] + dp[i-2]

vector<int> dp;
class Solution {
public:
    int climbStairs(int n) {
        dp.resize(n + 1, 0);
        dp[0] = 1;
        dp[1] = 1;
        for(int i = 2; i <= n; i++) dp[i] = dp[i-1] + dp[i-2];
        return dp[n];
    }
};

结果：

执行用时：0 ms, 在所有 C++ 提交中击败了100.00% 的用户

内存消耗：6.1 MB, 在所有 C++ 提交中击败了42.87% 的用户

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。

dp[i] = max(dp[i-1],prices[i]-lowest); lowest = min(lowest, prices[i]);

// dp[i] : 前i的最大利润。i:天数
// 状态转移 ：1)对当天的股票，不操作,最大利润等于前一天；2)卖出，并与前一i-1天利润对比；3)买入；记录当前股票价格是否为局部最小值
// dp[i] = max(dp[i-1],prices[i]-lowest); lowest = min(lowest, prices[i]);
vector<int> dp;
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size() == 0) return 0;
        dp.resize(prices.size(), 0);
        dp[0] = 0;
        int lowest = prices[0];
        for(int i = 1; i < prices.size(); i++){
            dp[i] = max(dp[i-1], prices[i] - lowest);
            lowest = min(lowest, prices[i]);
        }
        return dp[prices.size() - 1];
    }
};

结果：

执行用时：8 ms, 在所有 C++ 提交中击败了95.73% 的用户

内存消耗：13.3 MB, 在所有 C++ 提交中击败了9.41% 的用户