动态规划总结

Posted 2021-03-09 hoo334

 

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

示例:

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

f(k) 表示连续以下标为k的元素结尾的和，f(k) = max(nums[k], nums[k]+f(k-1)),如果f(k) < 0 ，从当前元素开始求和

    public int maxSubArray(int[] nums) {
        int max = nums[0];
        int sum = nums[0];
        for(int i=1;i<nums.length;++i){
            sum = Math.max(nums[i],sum+nums[i]);
            max = Math.max(max,sum);
        }
        return max;
    }

 

 

 

给定一个数组，它的第 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。

前 i 天的最大收益 = max( 前 i-1 天的最大收益，第 i 天的股票价格 - 前 i-1 天 股票的最低价格)

我们需要维护一个前 i 天的股票价格

    public int maxProfit(int[] prices) {
        if(prices.length <= 1)
        return 0;

        int max = 0,min = prices[0];
        for(int i = 1;i<prices.length;++i){
            max=Math.max(max,prices[i]-min);
            min=Math.min(prices[i],min);
        }
        return max;
    }

 

 

数组的每个索引做为一个阶梯，第 i个阶梯对应着一个非负数的体力花费值 cost[i](索引从0开始)。

每当你爬上一个阶梯你都要花费对应的体力花费值，然后你可以选择继续爬一个阶梯或者爬两个阶梯。

您需要找到达到楼层顶部的最低花费。在开始时，你可以选择从索引为 0 或 1 的元素作为初始阶梯。

示例 1:

输入: cost = [10, 15, 20]
输出: 15
解释: 最低花费是从cost[1]开始，然后走两步即可到阶梯顶，一共花费15。
 示例 2:

输入: cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1]
输出: 6
解释: 最低花费方式是从cost[0]开始，逐个经过那些1，跳过cost[3]，一共花费6。
注意：

cost 的长度将会在 [2, 1000]。
每一个 cost[i] 将会是一个Integer类型，范围为 [0, 999]。

第 i 级台阶的花费 = min(前 i-1 级台阶的花费，前 i-2 级台阶的花费) + 当前第 i 级台阶的花费，判断一次走一级还是两级花费少。

    public int minCostClimbingStairs(int[] cost) {
        int pre = 0, pre2 = 0;
        for(int i = 0;i < cost.length ;i++){
            int cur = cost[i] + Math.min(pre,pre2);
            pre2 = pre;
            pre = cur;
        }

        return Math.min(pre,pre2);
    }