动态规划_leetcode300(LIS)

#coding=utf-8

# 递归1### 选与不选 经典的组合问题

class Solution1(object):    def lengthOfLIS(self, nums):        """        :type nums: List[int]        :rtype: int        """        self.res = 0

        if not nums :            return 0

        ans = []        self.getLIS(nums,0,ans)

        return self.res

    def  getLIS(self,nums,index,ans):

        if index == len(nums):            if self.isLIS(ans):                self.res = max(self.res,len(ans))            return

        ans.append(nums[index])        self.getLIS(nums,index+1,ans)        ans.pop()        self.getLIS(nums,index+1,ans)

    def isLIS(self,ans):        if not ans:            return False

        if len(ans) == 1:            return True

        pre = 0        next = 1

        while next < len(ans):            if ans[pre] > ans[next]:                return False            else:                pre += 1                next += 1

        return True

# s = Solution1()# nums1 = [10, 9, 2, 5, 3, 7, 101, 18]# print  s.lengthOfLIS(nums1)

# 递归2 生成所有的组合class Solution2(object):    def lengthOfLIS(self, nums):        """        :type nums: List[int]        :rtype: int        """

        self.res = 0        self.getCombination(nums,0,[])

        return self.res

    def isLIS(self,ans):        if not ans:            return False

        if len(ans) == 1:            return True

        pre = 0        next = 1

        while next < len(ans):            if ans[pre] > ans[next]:                return False            else:                pre += 1                next += 1

        return True

    def getCombination(self,nums,index,ans):

        if self.isLIS(ans):            self.res = max(self.res,len(ans))        for i in range(index,len(nums)):            ans.append(nums[i])            self.getCombination(nums,i+1,ans)            ans.pop()

# s = Solution2()# nums1 = [10, 9, 2, 5, 3, 7, 101, 18]# nums2 = [1,2,3]# print s.lengthOfLIS(nums1)

# 动态规划class Solution3(object):    def lengthOfLIS(self, nums):        """        :type nums: List[int]        :rtype: int        """

        memo = [1 for i in range(len(nums)) ]

        for i in range(len(nums)):            for j in range(i):                if nums[i] > nums[j]:                    memo[i] = max(memo[i],memo[j]+1)        res = 0        for i in range(len(nums)):            res = max(res,memo[i])        return ress = Solution3()nums1 = [10, 9, 2, 5, 3, 7, 101, 18]nums2 = [1,2,3]print s.lengthOfLIS(nums1)

原文地址:https://www.cnblogs.com/lux-ace/p/10546562.html

时间: 2024-10-10 22:24:35

动态规划_leetcode300(LIS)的相关文章

动态规划之LIS

这几天看了不少讲动态规划的书和文章,一般第一个例子就是斐波那契.这个例子真直观,可以将递归发,然后讲自顶向下,自底向上,都没问题. 动态规划还好嘛,not so hard. 但是,从第二个问题开始就不那么直观了. 最喜欢被人用的第二个例子就是这个LIS Longest increasing sequence. 从一个序列里找出最长的升序子序列的长度: 比如:10,22,9,33,21,50,41,60,80 这个数字序列的最长生升序子序列是10 22 33 50 60 80 , 长度是6.最长升

动态规划——E (LIS())最长上升子序列

E - LIS Time Limit:1000MS     Memory Limit:65536KB     64bit IO Format:%I64d & %I64u Submit Status Description The world financial crisis is quite a subject. Some people are more relaxed while others are quite anxious. John is one of them. He is very

UVa 10051 - Tower of Cubes

题目:给你n个正方体,每个面有一种颜色,他们按照重量递增的方式排列着,现在要求把他们排成一个塔, 每层一个正方体,要求每个正方体上面的正方体的重量全都小于他,还要保证接触的面上的颜色相同, 问最高能摆放多少层,答案不唯一. 分析:dp,动态规划,lis.最大不下降子序列,已经排好序,满足接触的面颜色相同即可. 定义状态:f(i,k)为以第i个方块作为顶时,k面朝上时的最大高度: 转移方程:f(i,k)= max(f(j,f))  { j < i,且相接处的面相同 }: 每个方块有6中摆放法式,利

动态规划(DP),类似LIS,FatMouse&#39;s Speed

题目链接:http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1108 解题报告: 1.首先按照weight从小到大排列,weight相同的按照speed从大到小排列; 2.Count[i]表示到第i个老鼠时,所求的最长“速度递减”子序列的长度: 3.path[i]=j是题目的关键,记录在Count[i]=Count[j]时,即最长“速度递减”子序列最后一个老鼠的前一只老鼠的位置 4.递归输出id void output(in

动态规划 LCS,LIS

1.最大连续子序列 dp[i]=max(dp[i-1]+a[i],a[i]) 以i为结尾 2.最大不连续子序列 dp[i]=max(dp[j]+a[i],dp[j]) 3.最大连续递增子序列 if a[i]>a[j] dp[i]=max(dp[i-1]+a[i],a[i]) 4.最大不连续递增子序列 if a[i]>a[j] dp[i]=max(dp[j]+a[i],dp[j]) 5.最长不连续公共子序列 if a[i-1]==b[j-1] dp[i][j]=dp[i-1][j-1]+1; e

动态规划专题小结:最长上升子序列(LIS)问题

(1)问题描述:给定n个整数A1,A2,A3...An.按照从左往右的顺序选择尽可能多的整数,组成一个上升子序列,其中相邻元素不能相等. (2)解题思路:本题就是经典的最长上升子序列问题(Longest Increasing Subsequence,LIS).可以通过动态规划解决.定义状态d(i)表示以下标i结尾的LIS的最大长度.那么不难得到如下状态转移方程: d(i)=max{0,d(j)|j<i,Aj<Ai}+1; 最终的答案为max{d(i)}.时间复杂度为O(N^2).由于这种方法十

【动态规划+二分查找】POJ2533&amp;POJ1631最长上升子序列(LIS)

POJ2533裸的LIS,时间复杂度为O(n^2) 1 #include<iostream> 2 #include<cstdio> 3 using namespace std; 4 const int MAXN=1000+5; 5 int a[MAXN]; 6 int dp[MAXN]; 7 int n,ans; 8 9 int main() 10 { 11 scanf("%d",&n); 12 for (int i=0;i<n;i++) 13 {

动态规划 - 最长递增子序列LIS

问题:一个序列有N个数:A[1],A[2],-,A[N],求出最长非降子序列的长度 样例输入:3 1 2 6 5 4 思路: 首先把问题简单化.可以先求A[1],...A[i]的最长非降子序列,令dp[i]为以A[i]结尾的最长非降子序列.当i = 1 时, 明显是长度dp[1] = 1 : i = 2 时,前面没有比1小的数字,故dp[2]=1 , 此时的最长非降子序列为1 ; i = 3 时,比数字2小的数是1 ,并且只有1 , 分析可知 dp[3] = dp[2]+1:当i = 4 时,找

尝试解释LIS(最长递增子序列)的一种动态规划算法

最长上升子序列就是求给定序列的最长的递增序列,其中不要求序列的元素在原序列中保持连续. 为了方便理解,可以举个例子: inta[] = {0,2,1,5,3,6,4,8,9,7}(数组下标从1开始)的一个最长的子序列1,3,4,7,9. 利用动态规划的思想,可以方便的求取这个解. 为了方便解释,我们定义dp(n)为长度为1至下标为n的最长子序列的长度(数组下标假设从1开始),{a[1],a[2],..,a[n]}为dp(n)对应的序列. 为了和程序对应,我采取自底向上的方式进行解释. 1.显然对