算法编程题总结(2)动态规划

动态规划的一般思路是：
将大问题分解为小问题，即，将一个问题考虑成一步一步解决的子问题。
https://blog.csdn.net/m0_37789876/article/details/82853572
这篇博客对动态规划问题的讲解不错。

1.leetcode(53)最大子序列的和
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例:
输入: [-2,1,-3,4,-1,2,1,-5,4],
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。
利用动态规划的思想，将问题划分为：以nums[i]结尾时所能构成的最大连续子数组，假设为m[i]
则m[i] = max(m[i-1]+nums[i],nums[i])。
将m[i]视为nums[i]，程序可写如下：

class Solution(object):
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if not nums:return 0
        
        for i in range(1,len(nums)):
            nums[i] = max(nums[i-1]+nums[i],nums[i])
        return max(nums)

2.leetcode(62)不同路径
一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。
问总共有多少条不同的路径？
https://leetcode-cn.com/problems/unique-paths/

本题同样可以用递归的方法求解，并且下面这种求解方法存在重复计算，可以进行优化。
设dp[i][j]为到达i行j列处的最多的路径数，按照动态规划一步一步分解的思想，由于机器人只能向右或者向下移动，则到达该点的方法只可能是从(i-1,j)和(i,j-1)两个点。
所以有dp[i][j] = dp[i-1][j]+dp[i][j-1]。
并且，所有边界只有一种走法，第一行都是向右走，第一列都是向下走，所以都置为1.
程序如下：

class Solution(object):
    def uniquePaths(self,m, n):
        dp = [[0 for _ in range(n)] for _ in range(m)]
        for i in range(m):
            dp[i][0] = 1
        for j in range(n):
            dp[0][j] = 1
        for i in range(1, m):
            for j in range(1, n):
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
        return dp[-1][-1]

3.leetcode(63)不同路径 II

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。

现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？
网格中的障碍物和空位置分别用 1 和 0 来表示。

说明：m 和 n 的值均不超过 100。

示例 1:

输入:
[
[0,0,0],
[0,1,0],
[0,0,0]
]
输出: 2
解释:
3x3 网格的正中间有一个障碍物。
从左上角到右下角一共有 2 条不同的路径：

1. 向右 -> 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右 -> 向右

https://leetcode-cn.com/problems/unique-paths-ii
思路：这个程序中，matrix[0][1] = 1和matrix[1][0] = 1的意义是相同的，都是给初始一个起点的值，并且，由于考虑到边界的因素，这里把行数和列数都加了1。
如果遇到了障碍物，则可以将障碍物这一点的值置为0，意思是从这一点并没有路线可以出发。

if obstacleGrid[i-1][j-1] != 1：
	matrix[i][j] = matrix[i-1][j] + matrix[i][j - 1]  
else：
	0

程序如下：

class Solution:
    def uniquePathsWithObstacles(self, obstacleGrid):
        matrix = [[0 for _ in range(len(obstacleGrid[0])+1)]
                  for _ in range(len(obstacleGrid)+1)]
        matrix[0][1] = 1
        for i in range(1, len(matrix)):
            for j in range(1, len(matrix[0])):
           	 	if obstacleGrid[i-1][j-1] != 1：
                	matrix[i][j] = matrix[i-1][j] + matrix[i][j - 1]
                else:
                	0
        return matrix[-1][-1]

未完待续