博客

爬楼梯

假设你正在爬楼梯。需要

n

阶你才能到达楼顶。

每次你可以爬

1

或

2

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

示例 1：

输入：n = 2

输出：2

解释：有两种方法可以爬到楼顶。

1. 1 阶 + 1 阶

2. 2 阶

示例 2：

输入：n = 3

输出：3

解释：有三种方法可以爬到楼顶。

1. 1 阶 + 1 阶 + 1 阶

2. 1 阶 + 2 阶

3. 2 阶 + 1 阶

class Solution {
public:
    int climbStairs(int n) {
        // 动态规划
        int dp[n+5];
        dp[1] = 1,dp[2] = 2;
        for(int i=3;i<=n;i++){
            dp[i] = dp[i-1] + dp[i-2];
        }
        return dp[n];
    }
};

合并区间

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。

示例 1：

输入：intervals = [[1,3],[2,6],[8,10],[15,18]]

输出：[[1,6],[8,10],[15,18]]

解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

示例 2：

输入：intervals = [[1,4],[4,5]]

输出：[[1,5]]

解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        sort(intervals.begin(),intervals.end());
        vector<vector<int>> ans;
        int p=0;
        ans.push_back(intervals[0]);
        for(int i=1;i<intervals.size();i++){
            if(ans[p][1] >= intervals[i][0]){
                if(ans[p][1] <= intervals[i][1])
                    ans[p][1] = intervals[i][1];
            }else{
                ans.push_back(intervals[i]);
                p++;
            }
        }
        return ans;
        // return intervals;
    }
};

买卖股票的最佳时机 II

给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。

在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。

返回 你能获得的 最大 利润 。

示例 1：

输入：prices = [7,1,5,3,6,4]

输出：7

解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 – 1 = 4 。

随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 – 3 = 3 。

总利润为 4 + 3 = 7 。

示例 2：

输入：prices = [1,2,3,4,5]

输出：4

解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 – 1 = 4 。

总利润为 4 。

示例 3：

输入：prices = [7,6,4,3,1]

输出：0

解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0 。

不同于

买卖股票的最佳时机

，本题为进阶版本，之前的版本只需要找到数组的极小值和极大值，然后计算差值即可，本题也可使用类似的思想，只需要求所有上升区间的总和即可，另外本题也可以使用动态规划来解题，下面提供几种解题思路：

贪心法：

寻找所用区间的极小极大值

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int ans=0;
        int p1=0,p2=0;
        int n=prices.size();
        while(p1<n&&p2<n){
            // 寻找极小值
            while( p1+1<n &&  prices[p1]>prices[p1+1]){
                p1++;
            }
            p2=p1;
            // 寻找极大值
            while( ( p2+1<n )   && (prices[p2]<prices[p2+1])   ){
                p2++;
            }
            ans+=prices[p2]-prices[p1];
            p1=p2+1;
        }
        return ans;
    }
};

求所有上升区间的总和

class Solution {
public:
    int maxProfit(vector<int>& nums) {
        int res=0;
        for(int i=1;i<nums.size();i++){
            if(nums[i]>nums[i-1]){
                res+=nums[i]-nums[i-1];
            }
        }
        return res;
    }
};

动态规划：

class Solution {
public:
    int maxProfit(vector<int>& nums) {
        // 动态规划
        int n=nums.size();
        int dp[nums.size()][2];
        dp[0][0]=0,dp[0][1]=-nums[0];
        for(int i=1;i<n;i++){
            if(dp[i-1][0]>dp[i-1][1]+nums[i]){
                dp[i][0]=dp[i-1][0];
            }else{
                dp[i][0]=dp[i-1][1]+nums[i];
            }
            if(dp[i-1][1]>dp[i-1][0]-nums[i]){
                dp[i][1]=dp[i-1][1];
            }else{
                dp[i][1]=dp[i-1][0]-nums[i];   
            }
            //dp[i][0]=max(dp[i-1][0],dp[i-1][1]+nums[i])；
            //dp[i][1]=max(dp[i-1][1],dp[i-1][0]-nums[i]);
        }
        return dp[n-1][0];
    }
};