算法刷题：LC初级算法动态规划类

Posted 2021-05-18 看，未来

文章目录

• • 买卖股票的最佳时机
  • 最大子序和
  • 打家劫舍

买卖股票的最佳时机

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

示例 1：

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

示例 2：

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

提示：

1 <= prices.length <= 10^5
0 <= prices[i] <= 10^4

作者：力扣 (LeetCode)
链接：https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/xn8fsh/
来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

---

思路：
由于只能买卖一次，可以维护一个最大利润点，以及一个当前最低价点，然后天数向后偏移，不断的用每天的新价格去减去最低价，获取新的收益值，再与最大利润值进行比对，取二者大的为新的利润点。

int maxProfit(vector<int>& prices) {
    int profit = 0;
    int price = prices[0];

    for(int i = 1;i<prices.size();i++){
        profit = max(profit,prices[i] - price);
        if(prices[i] < price)
            price = prices[i];
    }
    return profit;
}

---

最大子序和

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

示例 1：

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

示例 2：

输入：nums = [1]
输出：1

示例 3：

输入：nums = [0]
输出：0

示例 4：

输入：nums = [-1]
输出：-1

示例 5：

输入：nums = [-100000]
输出：-100000

提示：

1 <= nums.length <= 3 * 104
-10^5 <= nums[i] <= 10^5

进阶：如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的 分治法 求解。

作者：力扣 (LeetCode)
链接：https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/xn3cg3/
来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

---

思路：
那这题其实和上面是一样的思路，只要在遍历的过程中不断的维护一个最大序列和，当然，这里添加了一点，就是序列断开的情况。
什么时候要把两个序列断开呢，当某个序列遍历到和小于0了，这时候就要果断的断开。并将那个让序列小于0的老鼠屎剔除。

还有一种特殊情况，就是序列全部为负数，这个要额外注意一下。

int maxSubArray(vector<int>& nums) {
    int res = 0;    //预期返回的值
    int temp = 0;   //用来临时计数

    for(int i = 0;i<nums.size();i++){
        temp+=nums[i];
        res = max(res,temp);
        if(temp<0)
            temp = 0;

        //res_temp = max(res_temp,nums[i]);   
    }

    if(res == 0){   //如果全是负数，那也要取一个最大的出来啊
        res = INT_MIN;
        for(int i = 0;i<nums.size();i++)
            res = max(res,nums[i]);
    }

    return res;
}

---

打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

示例 1：

输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
     偷窃到的最高金额 = 1 + 3 = 4 。

示例 2：

输入：[2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
     偷窃到的最高金额 = 2 + 9 + 1 = 12 。

作者：力扣 (LeetCode)
链接：https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/xnq4km/
来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

---

思路：这个其实可以用逆向思维来做的。

面对前两家，我取一家。取哪一家呢？取潜在价值最高的那一家。
取完一家，在它后面的两家中取哪一家，依旧是潜在价值最高的那一家。

一次类推，最后会推到最后两家，那么倒推回来就行了。

这是贪心算法吧。

---

int rob(vector<int>& nums, int st, int size, int RobPre, int NotRobPre)
{
    if (size - st < 1)return NotRobPre > RobPre ? NotRobPre : RobPre;
        return rob(nums, st + 1, size, nums[st] + NotRobPre, RobPre > NotRobPre ? RobPre : NotRobPre);
}
int rob(vector<int>& nums)
{
    return rob(nums, 0, nums.size(), 0, 0);
}

---