LeetCode Dynamic Programming算法題（Easy級別）整理

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