leetcode 动态规划整理

动态规划整理

1.最长公共子序列

# 给定两个字符串?text1 和?text2,返回这两个字符串的最长公共子序列。
#
# 一个字符串的?子序列?是指这样一个新的字符串:它是由原字符串在不改变字符的相对顺序的情况下删除某些字符(也可以不删除任何字符)后组成的新字符串。
# 例如,"ace" 是 "abcde" 的子序列,但 "aec" 不是 "abcde"
# 的子序列。两个字符串的「公共子序列」是这两个字符串所共同拥有的子序列。
#
# 若这两个字符串没有公共子序列,则返回 0。

# 示例 1:
#
# 输入:text1 = "abcde", text2 = "ace"
# 输出:3
# 解释:最长公共子序列是 "ace",它的长度为 3。

class Solution(object):
    def longestCommonSubsequence(self, text1, text2):
        """
        :type text1: str
        :type text2: str
        :rtype: int
        """
        m,n=len(text1),len(text2)
        dp=[[0 for _ in range(m+1)] for _ in range(n+1)]
        for i in range(1,n+1):
            for j in range(1,m+1):
                str1=text1[:j]
                str2=text2[:i]
                if str1[-1]==str2[-1]:
                    dp[i][j]=dp[i-1][j-1]+1
                else:
                    dp[i][j]=max(dp[i-1][j],dp[i][j-1])
        return dp[-1][-1]

2.最长上升子序列

# 给定一个无序的整数数组,找到其中最长上升子序列的长度。
#
# 示例:
#
# 输入: [10,9,2,5,3,7,101,18]
# 输出: 4
# 解释: 最长的上升子序列是?[2,3,7,101],它的长度是 4。
#
# 说明:

# 可能会有多种最长上升子序列的组合,你只需要输出对应的长度即可。
# 你算法的时间复杂度应该为?O(n^2) 。
#
#
# 进阶: 你能将算法的时间复杂度降低到?O(n log n) 吗?

class Solution(object):
    def lengthOfLIS(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if not nums:return 0
        dp=[1]*len(nums)
        for i in range(1,len(nums)):
            for j in range(i):
                if nums[i] > nums[j]:
                    dp[i] = max(dp[i],dp[j] + 1)
        # 最后要全部走一遍,看最大值
        return max(dp)

3.爬楼梯

# 假设你正在爬楼梯。需要 n?阶你才能到达楼顶。
#
# 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢?
#
# 注意:给定 n 是一个正整数。
def climbStairs2(self, n):
    if n == 1:
        return 1
    res = [0 for i in xrange(n)]
    res[0], res[1] = 1, 2
    for i in xrange(2, n):
        res[i] = res[i-1] + res[i-2]
    return res[-1]

4.最长公共子串

#给两个字符串,返回它们的最长公共子串的长度

class Solution(object):
    def LCS(self,str1,str2):
        if not str1 or not str2:return 0
        dp=[[0 for _ in range(len(str1))] for _ in range(len(str2))]
        res=0

        for j in range(len(str1)):
            if str1[j]==str2[0]:
                dp[0][j]=1

        for i in range(len(str2)):
            if str2[i]==str1[0]:
                dp[i][0]=1

        for i in range(1,len(str2)):
            for j in range(1,len(str1)):
                if str1[j]==str2[i]:
                    dp[i][j]=dp[i-1][j-1]+1
                    res=max(res,dp[i][j])
        return res

原文地址:https://www.cnblogs.com/caoo/p/11741311.html

时间: 2024-10-28 19:19:28

leetcode 动态规划整理的相关文章

Leetcode 动态规划 Decode Ways

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie Decode Ways Total Accepted: 8689 Total Submissions: 55465 A message containing letters from A-Z is being encoded to numbers using the following mapping: 'A' -> 1 'B' -> 2 ... 'Z' -> 26 Given a

Leetcode 动态规划 Maximum Subarray

正整数或一位小数或者俩位小数的正则表达式的写法 ^(?!0+(?:\.0+)?$)(?:[1-9]\d*|0)(?:\.\d{1,2})?$ Leetcode 动态规划 Maximum Subarray,布布扣,bubuko.com

Leetcode 动态规划 Climbing Stairs

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie Climbing Stairs Total Accepted: 13319 Total Submissions: 40778 You are climbing a stair case. It takes n steps to reach to the top. Each time you can either climb 1 or 2 steps. In how many distinc

Leetcode动态规划【简单题】

目录 Leetcode动态规划[简单题] 53. 最大子序和 题目描述 思路分析 复杂度分析 70.爬楼梯 题目描述 思路分析 复杂度分析 121.买卖股票的最佳时机 题目描述 思路分析 复杂度分析 303.区域和检索-数组不可变 题目描述 思路分析 复杂度分析 Leetcode动态规划[简单题] 动态规划(Dynamic programming,简称DP),是一种把原问题分解为相对简单的子问题的方式求解复杂问题的方法.动态规划相较于递归,拥有更少的计算量. 53. 最大子序和 题目描述 给定一

快速上手leetcode动态规划题

快速上手leetcode动态规划题 我现在是初学的状态,在此来记录我的刷题过程,便于以后复习巩固. 我leetcode从动态规划开始刷,语言用的java. 一.了解动态规划 我上网查了一下动态规划,了解到动态规划是“带有备忘录的递归”, 而大多数用来理解动态规划的例子都是斐波那契数列,就是那个经典的递归式 f(i)=f(i-1)+f(i-2) ,f(1)=f(2)=1 那么我们就可以得到很多式子,比如求f(5): f(5)=f(4)+f(3); f(4)=f(3)+f(2); f(3)=f(2)

Leetcode文章整理

LeetCode的题目种类比较多,感觉应该将自己联系过的题目进行分类,这个就是根据自己做过的题目进行划分,并做一定的总结,会持续更新 Sort: Two Pointer: 单链表: Reorder List将l1->l2...->ln转化为l1->ln->l2->ln-1.. 这里用的很直接的方法就是找到链表的中点,然后将链表分为两部分,后半截翻转后两个链表进行融合.我在想,如果能之间把后面半截放入vector当中,就简单很多,但是就是牺牲了空间,不知道有没有更好的办法. I

[LeetCode] 动态规划入门题目

最近接触了动态规划这个厉害的方法,还在慢慢地试着去了解这种思想,因此就在LeetCode上面找了几道比较简单的题目练了练手. 首先,动态规划是什么呢?很多人认为把它称作一种"算法",其实我认为把它称作一种"思想"更为合适:利用动态规划去解决问题,其实就是逐步递推的过程,与贪心算法不同,动态规划递推的每一步都要求是当前的最优解(这是很重要的,递推的正确性依赖的就是这一点):利用动态规划解题时,必须自己定义出来状态和状态转移方程.然而,看上去简单,做起来却非常困难,因为

<LeetCode>动态规划——Two Sequences 类型题目

一.类型描述 Two Sequences 的题目一般会提供两个sequence,一般问最大/最小.true/false.count(*)这几类的问题. 其中,Two Sequences的动态规划题目的四要素: state:dp[i][j] 一般表示 第一个sequence的前i个字符 和 第二个sequence的前j个字符 怎么怎么样. Initialization: 这类型动态规划一般初始化dp数组的方式是根据题目的含义初始化第一行和第一列. function:解决动态规划的function问

LeetCode动态规划题总结【持续更新】

以下题号均为LeetCode题号,便于查看原题. 10. Regular Expression Matching 题意:实现字符串的正则匹配,包含'.' 和 '*'.'.' 匹配任意一个字符,"*" 匹配 '*' 之前的0个或多个字符. example: isMatch("aa","a") → false isMatch("aa","aa") → true isMatch("aaa",&