第九章 Dynamic Programming

最新推荐文章于 2024-03-30 03:29:17 发布

qq_turn

最新推荐文章于 2024-03-30 03:29:17 发布

阅读量252

点赞数

分类专栏： LintCode

本文链接：https://blog.csdn.net/qq_38441207/article/details/99055126

版权

LintCode 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

不同的路径
中文English
有一个机器人的位于一个 m × n 个网格左上角。

机器人每一时刻只能向下或者向右移动一步。机器人试图达到网格的右下角。

问有多少条不同的路径？

Example
Notice
n和m均不超过100
样例 1:

输入: n = 1, m = 3
输出: 1
解释: 只有一条通往目标位置的路径。
样例 2:

输入: n = 3, m = 3
输出: 6
解释:
D : Down
R : Right
1) DDRR
2) DRDR
3) DRRD
4) RRDD
5) RDRD
6) RDDR

动态规划的四要素：
1，给出定义
2，初始化
3，写出递推关系方程式
4，表示出答案
class Solution:
    def uniquePaths(self,m,n):
        '''
        2019/9/11
        1,definition
        dp[i][j] :the number of uniquePaths from the (0,0) to (i,j)
        2,initialization
        -dp[i][0]
        -dp[0][j]
        3,equation
        dp[i][j]=dp[i-1][j]+dp[i][j-1]
        4,answer
        dp[m-1][n-1]
        '''
        dp = [[0]*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[m-1][n-1]

a =Solution()
m = 3
n =3

print(a.uniquePaths(m,n))

不同的路径 II
中文English
“不同的路径” 的跟进问题：

现在考虑网格中有障碍物，那样将会有多少条不同的路径？

网格中的障碍和空位置分别用 1 和 0 来表示。

Example
Notice
m 和 n 均不超过100
Example
样例 1:
输入: [[0]]
输出: 1

样例 2:
输入: [[0,0,0],[0,1,0],[0,0,0]]
输出: 2

解释:
只有 2 种不同的路径.

#2019/9/12
class Solution:
    def uniquePathWithObstacles(self,obstacleGrid):
        m,n = len(obstacleGrid),len(obstacleGrid[0])
        dp = [[0] *n for _ in range(m)]

        for i in range(m):
            if obstacleGrid[i][0] == 0:
                dp[i][0] = 1
            else:
                dp[i][0] = 0
                break
        for j in range(n):
            if obstacleGrid[0][j] == 0:
                dp[0][j] = 1
            else:
                dp[0][j] = 0
                break
        for i in range(1,m):
            for j in range(1,n):
                if obstacleGrid[i][j] == 0:
                    dp[i][j] = dp[i-1][j]+dp[i][j-1]
                else:
                    dp[i][j] = 0
        return dp[m-1][n-1]

a=Solution()

obstacleGrid= [[0,0,0],[0,1,0],[0,0,0]]
b = a.uniquePathWithObstacles(obstacleGrid)
print(b)

爬楼梯
中文English
假设你正在爬楼梯，需要n步你才能到达顶部。但每次你只能爬一步或者两步，你能有多少种不同的方法爬到楼顶部？
样例 1:
输入: n= 3
输出: 3

样例解释：
1) 1, 1, 1
2) 1, 2
3) 2, 1
共3种

样例 2:
输入: n = 1
输出: 1

解释:  
只有一种方案

class Solution:
    '''
    2019/9/12
    1,definition
    -dp[i]: how many distinct ways to jump to step i
    2,answer
    -dp[n]
    3,state transfer equation
    -dp[i] = dp[i-1]+dp[i-2]
    4,initialization
    -dp[0]=1
    dp[1]=1
    '''
    def climbStairs(self,n):
        if n==0:
            return 0
        if n in [1,2]:
            return n
        dp = [0]*(n+1)
        dp[0] = 1
        dp[1] = 1
        for i in range(2,n+1):
            dp[i]=dp[i-1]+dp[i-2]

        return dp[n]
a=Solution()
num = int(input())
print(a.climbStairs(num))

272 爬楼梯2

一个小孩爬一个 n 层台阶的楼梯。他可以每次跳 1 步， 2 步或者 3 步。实现一个方法来统计总共有多少种不同的方式爬到最顶层的台阶。

样例

n = 3
1 + 1 + 1 = 2 + 1 = 1 + 2 = 3 = 3
返回 4.

// An highlighted block
var foo = 'bar';

最小路径和
中文English
给定一个只含非负整数的m*n网格，找到一条从左上角到右下角的可以使数字和最小的路径。

Example
样例 1:
输入: [[1,3,1],[1,5,1],[4,2,1]]
输出: 7

样例解释：
路线为： 1 -> 3 -> 1 -> 1 -> 1。

样例 2:
输入: [[1,3,2]]
输出: 6

解释:  
路线是： 1 -> 3 -> 2

Notice
你在同一时间只能向下或者向右移动一步

数字三角形
中文English
给定一个数字三角形，找到从顶部到底部的最小路径和。每一步可以移动到下面一行的相邻数字上。

Example
样例 1

输入下列数字三角形：
[
[2],
[3,4],
[6,5,7],
[4,1,8,3]
]
输出： 11
解释：从顶到底部的最小路径和为11 ( 2 + 3 + 5 + 1 = 11)。
样例 2

输入下列数字三角形：
[
[2],
[3,2],
[6,5,7],
[4,4,8,1]
]
输出： 12
解释：从顶到底部的最小路径和为12 ( 2 + 2 + 7 + 1 = 12)。
Notice
如果你只用额外空间复杂度O(n)的条件下完成可以获得加分，其中n是数字三角形的总行数。

跳跃游戏
中文English
给出一个非负整数数组，你最初定位在数组的第一个位置。

数组中的每个元素代表你在那个位置可以跳跃的最大长度。

判断你是否能到达数组的最后一个位置。

Example
样例 1

输入 : [2,3,1,1,4]
输出 : true
样例 2

输入 : [3,2,1,0,4]
输出 : false
Notice
这个问题有两个方法，一个是贪心和动态规划。

贪心方法时间复杂度为O（N）。

动态规划方法的时间复杂度为为O（n^2）。

我们手动设置小型数据集，使大家可以通过测试的两种方式。这仅仅是为了让大家学会如何使用动态规划的方式解决此问题。如果您用动态规划的方式完成它，你可以尝试贪心法，以使其再次通过一次。

跳跃游戏 II
中文English
给出一个非负整数数组，你最初定位在数组的第一个位置。

数组中的每个元素代表你在那个位置可以跳跃的最大长度。

你的目标是使用最少的跳跃次数到达数组的最后一个位置。

Example
样例 1

输入 : [2,3,1,1,4]
输出 : 2
解释 : 到达最后位置的最小跳跃次数是2(从下标0到1跳跃1个距离长度，然后跳跃3个距离长度到最后wei’z)

最长上升子序列
中文English
给定一个整数序列，找到最长上升子序列（LIS），返回LIS的长度。

Example
样例 1:
输入: [5,4,1,2,3]
输出: 3

解释:
LIS 是 [1,2,3]

样例 2:
输入: [4,2,4,5,3,7]
输出: 4

解释: 
LIS 是 [2,4,5,7]

Challenge
要求时间复杂度为O(n^2) 或者 O(nlogn)

Clarification
最长上升子序列的定义：

最长上升子序列问题是在一个无序的给定序列中找到一个尽可能长的由低到高排列的子序列，这种子序列不一定是连续的或者唯一的。
https://en.wikipedia.org/wiki/Longest_increasing_subsequence

单词拆分 III
中文English
给出一个单词表和一条去掉所有空格的句子，根据给出的单词表添加空格, 返回可以构成的句子的数量, 保证构成的句子中所有的单词都可以在单词表中找到.

Example
样例1

输入：
“CatMat”
[“Cat”, “Mat”, “Ca”, “tM”, “at”, “C”, “Dog”, “og”, “Do”]
输出： 3
解释：
我们可以有如下三种方式：
“CatMat” = “Cat” + “Mat”
“CatMat” = “Ca” + “tM” + “at”
“CatMat” = “C” + “at” + “Mat”
样例2

输入：
“a”
[]
输出： 0
Notice
忽略大小写

1. 骑士的最短路线
- 给定骑士在棋盘上的初始位置(一个2进制矩阵 0 表示空 1 表示有障碍物)，找到到达终点的最短路线，返回路线的长度。如果骑士不能到达则返回 -1

青蛙跳
中文English
一只青蛙正要过河，这条河分成了 x 个单位，每个单位可能存在石头，青蛙可以跳到石头上，但它不能跳进水里。
按照顺序给出石头所在的位置，判断青蛙能否到达最后一块石头所在的位置。刚开始时青蛙在第一块石头上，假设青蛙第一次跳只能跳一个单位的长度。
如果青蛙最后一个跳 k 个单位，那么它下一次只能跳 k - 1 ，k 或者 k + 1 个单位。注意青蛙只能向前跳。

Example
样例 1:

给出石头的位置为 [0,1,3,5,6,8,12,17]
输入:
[0,1,3,5,6,8,12,17]
输出:
true

解释:
总共8块石头。
第一块石头在 0 位置，第二块石头在 1 位置，第三块石头在 3 位置等等…
最后一块石头在 17 位置。
返回 true。青蛙可以通过跳 1 格到第二块石头，跳 2 格到第三块石头，跳 2 格到第四块石头，跳 3 格到第六块石头，跳 4 格到第七块石头，最后跳 5 格到第八块石头。
样例 2:

给出石头的位置为 [0,1,2,3,4,8,9,11]
输入:
[0,1,2,3,4,8,9,11]
输出:
false

解释:
返回 false。青蛙没有办法跳到最后一块石头因为第五块石头跟第六块石头的距离太大了。
Notice
石头的个数 >= 2并且 <= 1100。
每块石头的位置是一个非负数并且 < 2^31。
第一块石头的位置总是 0.

分割回文串 II
中文English
给定字符串 s, 需要将它分割成一些子串, 使得每个子串都是回文串.

最少需要分割几次?

Example
样例 1:

输入: “a”
输出: 0
解释: “a” 本身就是回文串, 无需分割
样例 2:

输入: “aab”
输出: 1
解释: 将 “aab” 分割一次, 得到 “aa” 和 “b”, 它们都是回文串.

最大子数组
中文English
给定一个整数数组，找到一个具有最大和的子数组，返回其最大和。

Example
样例1:

输入：[−2,2,−3,4,−1,2,1,−5,3]
输出：6
解释：符合要求的子数组为[4,−1,2,1]，其最大和为 6。
样例2:

输入：[1,2,3,4]
输出：10
解释：符合要求的子数组为[1,2,3,4]，其最大和为 10。
Challenge
要求时间复杂度为O(n)

Notice
子数组最少包含一个数

最大子数组 III
中文English
给定一个整数数组和一个整数 k，找出 k 个不重叠子数组使得它们的和最大。每个子数组的数字在数组中的位置应该是连续的。

返回最大的和。

Example
样例1

输入:
List = [1,2,3]
k = 1
输出: 6
说明: 1 + 2 + 3 = 6
样例2

输入:
List = [-1,4,-2,3,-2,3]
k = 2
输出: 8
说明: 4 + (3 + -2 + 3) = 8
Notice
子数组最少包含一个数

完美平方
中文English
给一个正整数 n, 请问最少多少个完全平方数(比如1, 4, 9…)的和等于n。

Example
样例 1:

输入: 12
输出: 3
解释: 4 + 4 + 4
样例 2:

输入: 13
输出: 2
解释: 4 + 9

qq_turn

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第九章 Dynamic Programming

不同的路径中文English有一个机器人的位于一个 m × n 个网格左上角。机器人每一时刻只能向下或者向右移动一步。机器人试图达到网格的右下角。问有多少条不同的路径？ExampleNoticen和m均不超过100...
复制链接

扫一扫

专栏目录