动态规划(四)——区间型动态规划

这里写图片描述

最长回文序列

这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述

class Solution:
    """
    @param s: the maximum length of s is 1000
    @return: the longest palindromic subsequence's length
    """
    def longestPalindromeSubseq(self, s):
        # write your code here
        if not s:
            return 0

        n=len(s)

        res=[[0]*n for i in range(n)]

        #init
        for i in range(n):
            res[i][i]=1 # length 1
            if i>=1: #length 2
                if s[i-1]==s[i]:
                    res[i-1][i]=2
                else:
                    res[i-1][i]=1


        for l in range(3,n+1):
            for i in range(n-l+1):
                j=i+l-1 # left:i right:j
                res[i][j]=max(res[i+1][j],res[i][j-1])
                if s[i]==s[j]:
                    res[i][j]=max(res[i][j],res[i+1][j-1]+2)

        return res[0][n-1]

记忆化搜索方法:
这里写图片描述

class Solution:
    """
    @param s: the maximum length of s is 1000
    @return: the longest palindromic subsequence's length
    """
    def longestPalindromeSubseq(self, s):
        # write your code here
        if not s:
            return 0

        n=len(s)
        res=[[0]*n for _ in range(n)]
        for i in range(n):
            for j in range(n):
                res[i][j]=-1

        def compute(s,i,j):
            if res[i][j]!=-1:
                return ##important

            if i==j:
                res[i][j]=1
                return

            if j-i==1:
                if s[i]==s[j]:
                    res[i][j]=2
                else:
                    res[i][j]=1
                return

            compute(s,i+1,j)
            compute(s,i,j-1)
            compute(s,i+1,j-1)

            res[i][j]=max(res[i+1][j],res[i][j-1])
            if s[i]==s[j]:
                res[i][j]=max(res[i][j],res[i+1][j-1]+2)

        compute(s,0,n-1)

        return res[0][n-1]

Coins in a line3

这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述
确定状态:
f[i][j] f [ i ] [ j ] 为一方先手在面对 a[i],,a[j] a [ i ] , ⋯ , a [ j ] 这些数字时,能得到的最大的与对手的数字差:

f[i][j]=max(a[i]f[i1][j],a[j]f[i][j1]) f [ i ] [ j ] = m a x ( a [ i ] − f [ i − 1 ] [ j ] , a [ j ] − f [ i ] [ j − 1 ] )

个人理解,博弈就是先想一步,当前先手取数的时候,不仅要考虑取的这个数给自己当前带来的增益,也要考虑取走这个数后对手可能获得的增益。

def coins(lst):
    n=len(lst)
    f=[[0]*n for _ in range(n)]

    for i in range(n):
        f[i][i]=lst[i]

    for length in range(2,n+1):
        for i in range(n-length+1):
            j=i+length-1
            f[i][j]=max(lst[i]-f[i+1][j],lst[j]-f[i][j-1])
            print (lst)
            print ("f[{}][{}]=max({}-f[{}][{}],{}-f[{}][{}])".format(i,j,lst[i],i+1,j,lst[j],i,j-1))
            print ("f[{}][{}]={}\n".format(i,j,f[i][j]))

    return f[0][n-1]>=0

Scramble String

f[i][j][k] f [ i ] [ j ] [ k ] 表示S1能否通过替换转为T1,其中
- S1为从字符i开始的长度为k的字符串
- T1为从字符j开始的长度为k的字符串

class Solution:
    """
    @param s1: A string
    @param s2: Another string
    @return: whether s2 is a scrambled string of s1
    """
    def isScramble(self, s1, s2):
        # write your code here

        if not s1:
            return True

        n=len(s1)
        f=[[[False]*(n+1) for _ in range(n)] for _ in range(n)]

        for i in range(n):
            for j in range(n):
                if s1[i]==s2[j]:
                    f[i][j][1]=True
                else:
                    f[i][j][1]=False

        for k in range(2,n+1):
            for i in range(n-k+1):
                for j in range(n-k+1):
                    for w in range(1,k):
                        if f[i][j][w] and f[i+w][j+w][k-w]:
                            f[i][j][k]=True
                            break
                        if f[i][j+k-w][w] and f[i+w][j][k-w]:
                            f[i][j][k]=True
                            break

        return f[0][0][n]

Burst Balloons

这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述

class Solution:
    """
    @param nums: A list of integer
    @return: An integer, maximum coins
    """
    def maxCoins(self, nums):
        # write your code here
        if not nums:
            return 0

        n=len(nums)
        nums.insert(0,1)
        nums.append(1)
        f=[[0]*(n+2) for _ in range(n+2)]

        #f[i][j]=max(f[i][k]+f[k][j]+nums[i]*nums[j]*nums[k])i<k<j

        for i in range(n+1):
            f[i][i+1]=0

        length=1   
        while length<=n:
            i=0
            while i+length+1<=n+1:
                j=i+length+1
                for k in range(i+1,j):
                    f[i][j]=max(f[i][k]+f[k][j]+nums[i]*nums[j]*nums[k],f[i][j])
                i=i+1
            length=length+1

        return f[0][n+1]
  • 0
    点赞
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值