LeetCode Dynamic Programming算法题（Easy级别）整理

2019年11月6日 177次阅读

53. Maximum Subarray

题目简介：给定一串数nums，找出某子串，该子串的所有数之和最大，并返回该最大值。

解题思路：对数串进行遍历，设cur为以当前数nums[i]为目标子串的最后一个数的最大值，ans为最后的结果。若以nums[i-1]为结尾数的最大子串之和为负，则从nums[i]开始重新求解；否则，加上nums[i]。代码如下：

class Solution(object):
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if not nums:
            return 0
        cur = 0
        ans = nums[0]
        for n in nums:
            if cur < 0:
                cur = n
            else:
                cur+=n
            if cur > ans:
                ans = cur
        return ans

又或者换种角度思考，此类问题也就是常说的局部最小与全局最小的求解。代码如下：

class Solution(object):
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        local1 = 0
        local2 = 0
        global1 = nums[0]
        global2 = 0
        for n in nums:
            local2 = max(n,local1+n)
            global2 = max(local2,global1)
            local1 = local2
            global1 = global2
        return global2

70. Climbing Stairs

题目简介：给定一个数n，代表一个有n阶的楼梯，你每次只能走一到两阶，求有多少种不同的走到顶的方法。

解题思路：阶梯数n较少时，可以直接返回结果；对于i>=3的情况，易知到达第i层可由上一层或上两层跨一步或两步实现，也就是到达第i层的走法为到达第i-1和i-2层的走法之和。代码如下：

class Solution(object):
    def climbStairs(self, n):
        """
        :type n: int
        :rtype: int
        """
        if n < 4:
            return n
        twoSteps = 2
        oneStep = 3
        ans = 0
        for i in range(3,n):
            ans = oneStep+twoSteps
            twoSteps = oneStep
            oneStep = ans
        return ans

121. Best Time to Buy and Sell Stock

题目简介：给定一串数代表股价的变动情况，若最多只能进行一次交易，求能获得的最大收益是多少。

解题思路：一轮遍历，依次追踪当前最小值与最大收益，并进行适时更新。代码如下：

class Solution(object):
    def maxProfit(self, prices):
        """
        :type prices: List[int]
        :rtype: int
        """
        if len(prices) < 2:
            return 0
        minPrice = prices[0]
        maxProfit = 0
        for p in prices[1:]:
            if p < minPrice:
                minPrice = p
            elif p - minPrice > maxProfit:
                maxProfit = p - minPrice
        return maxProfit

198. House Robber

题目简介：给定一串数，每个数代表一个房间内可供抢劫的财产。你不能抢劫相邻的房子，否则会触发警报。求你能抢得的最大收益。

解题思路：一轮遍历，对于当前房子，要么可以抢要么不可以抢，抢的话则前一个房子未被抢过，否则，抢过。判断是抢还是不抢对于当前收益影响大进行变量的更新。代码如下：

class Solution(object):
    def rob(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        previousRobed = 0
        previousNotRobed = 0
        maxProfit = 0
        for n in nums:
            maxProfit = max(previousRobed,previousNotRobed+n)
            previousNotRobed = previousRobed
            previousRobed = maxProfit
        return maxProfit

303. Range Sum Query – Immutable

题目简介：给定一串数，求指定下标间的数之和（会多次求解）。

解题思路：这道题主要的难点就是题目就是多次求解，多次求解中会有很多数据重复计算的问题，降低了效率，所以在初始化中就生成从第一个数开始，到之后若干数的和的话，会大大减少总运行时间。代码如下：

class NumArray(object):
    def __init__(self, nums):
        """
        :type nums: List[int]
        """
        if not nums:
            return
        self.nums = [0]*(len(nums)+1)
        for i in range(1,len(self.nums)):
            self.nums[i] = self.nums[i-1]+nums[i-1]

    def sumRange(self, i, j):
        """
        :type i: int
        :type j: int
        :rtype: int
        """
        return self.nums[j+1]-self.nums[i]

# Your NumArray object will be instantiated and called as such:
# obj = NumArray(nums)
# param_1 = obj.sumRange(i,j)

746. Min Cost Climbing Stairs

题目简介：爬梯规则与70. Climbing Stairs一致，只是此时每一个阶梯上都有一个数值，表示爬到该阶时会有相应的损耗，求损耗最小的爬梯方式产生的损耗。

解题思路：可以从小到大，依次递推。依次算出跳到第i阶上的最小损耗是多少，直到算到i=n为止。代码如下：

class Solution(object):
    def minCostClimbingStairs(self, cost):
        """
        :type cost: List[int]
        :rtype: int
        """
        l = len(cost)
        if l < 2:
            return 0
        cost.append(0)
        minCost = 0
        minCost1 = cost[0]
        minCost2 = cost[1]
        for i in range(2,l+1):
            minCost = min(minCost1,minCost2)+cost[i]
            minCost1 = minCost2
            minCost2 = minCost
        return minCost

点赞