【动态规划】经典题目小结（切割钢条、最长公共子序列、背包、硬币找零、数组组合、连续最大和、最长回文子序列）

最新推荐文章于 2024-07-25 10:54:19 发布

ferb2015

最新推荐文章于 2024-07-25 10:54:19 发布

阅读量1.4k

点赞数 1

分类专栏： python leetcode 笔试文章标签：动态规划 dp

本文链接：https://blog.csdn.net/eqiang8848/article/details/89671826

版权

python 同时被 3 个专栏收录

11 篇文章 0 订阅

订阅专栏

笔试

9 篇文章 0 订阅

订阅专栏

leetcode

3 篇文章 0 订阅

订阅专栏

切割钢条

参考《算法导论》和 http://www.cnblogs.com/mengwang024/p/4342796.html
自底向上，从r[0]开始，r[0]=0,r[n]=我们所要求的，第一个for遍历完后，所有从0-n的r最优解都得到了，第二个for，在每个i下，都求最优解，自底向上，最后i=n时，输出r[n]。

class Solution:
    def PrintBUCutRod(self, p, n, r, s):
        # write code here
        def ExtendedBUCutRod(p, n, r, s):           
            r[0] = 0
            for i in range(n+1)[1:]:
                q = -1
                for j in range(i+1)[1:]:
                    temp = p[j-1] + r[i-j]
                    if q < temp:
                        q = temp
                        s[i] = j
                r[i] = q
        ExtendedBUCutRod(p, n, r, s)
        print
        print('长度为' + str(n) + '的钢条最大收益为:' + str(r[n]))
        print('最优方案的钢条长度分别为:', end="")
        while n>0:
            print(s[n], end="")
            print(' ',end="")
            n =n -s[n]
        
        
n = 7
p=[1,5,8,9,10,17,17]
r = [0]*(n+1)    
s = [0]*(n+1)     
a = Solution().PrintBUCutRod(p,n,r,s)

最长公共子序列

《算法导论》15.4。
同时参考了视频，记录在《笔试题汇总》里。

class Solution:
    def PrintBUCutRod(self, s1, s2):
        # write code here
        lens1, lens2 = len(s1), len(s2) #lens1 列 ；lens2 行
        maxlen = [[0 for col in range(lens1+1)] for row in range(lens2+1)]
        for j in range(lens1+1):
            maxlen[0][j] = 0
        for i in range(lens2+1):
            maxlen[i][0] = 0
        for i in range(lens2+1)[1:]:
            for j in range(lens1+1)[1:]:
                if s1[j-1] == s2[i -1]:
                    maxlen[i][j] = maxlen[i-1][j-1] + 1
                else:
                    maxlen[i][j] = max(maxlen[i-1][j],maxlen[i][j-1])
        return maxlen[lens2][lens1]

01背包

参考了
https://blog.csdn.net/wzy_1988/article/details/12260343

https://www.kancloud.cn/kancloud/pack/70125

https://blog.csdn.net/xp731574722/article/details/70766804

https://blog.csdn.net/superzzx0920/article/details/72178544

def dppackage(n,c,w,v):
    dp = [0]*(c+1)
    for i in range(n+1):    
        for j in range(c,w[i]-1,-1):    #记得是 从大到小，从小到大是完全背包问题。#能取到w[i]
            dp[j] = max(dp[j], dp[j-w[i]]+v[i])
    print(dp[c])
    
n=5
c=10
w=[2,2,6,5,4]  
v=[6,3,5,4,6] 

w.insert(0,0)
v.insert(0,0)
dppackage(n,c,w,v)

网上的：

def bag(n,c,w,p):
    res=[[-1 for j in range(c+1)]for i in range(n+1)]
    for j in range(c+1):
        #第0行全部赋值为0，物品编号从1开始.为了下面赋值方便
        res[0][j]=0
    for i in range(1,n+1):
        for j in range(1,c+1):  
            res[i][j]=res[i-1][j]
            #生成了n*c有效矩阵，以下公式w[i-1],p[i-1]代表从第一个元素w[0],p[0]开始取。
            if j>=w[i-1] and res[i-1][j-w[i-1]]+p[i-1]>res[i][j]:
                res[i][j]=res[i-1][j-w[i-1]]+p[i-1]
    return res
#以下代码功能：标记出有放入背包的物品
#反过来标记，在相同价值情况下，后一件物品比前一件物品的最大价值大，则表示物品i#有被加入到背包，x数组设置为True。设初始为j=c。
def show(n,c,w,res):  
    print('最大价值为:',res[n][c])  
    x=[False for i in range(n)]  
    j=c  
    for i in range(1,n+1):  
        if res[i][j]>res[i-1][j]:  
            x[i-1]=True  
            j-=w[i-1]  
    print ('选择的物品为:' ) 
    for i in range(n):  
        if x[i]:  
            print ('第',i,'个,' )
    print('') 
if __name__=='__main__':  
    n=5  
    c=10  
    w=[2,2,6,5,4]  
    p=[6,3,5,4,6]  
    res=bag(n,c,w,p)  
    show(n,c,w,res)

硬币找零

最少的硬币凑够n元。

参考 https://blog.csdn.net/wdxin1322/article/details/9501163 （这个只能针对部分，没有对不可行的进行判断）

https://blog.csdn.net/u013805360/article/details/49392081

两个for循环，都是从小到大，然后以dp[i]=…（求min时）

class Solution:
    def coinChange(self, coins, amount):
        """
        :type coins: List[int]
        :type amount: int
        :rtype: int
        """
        
        dp = [amount+1]*(amount+1) #或写成 dp = [float('inf')]*(amount+1)
        dp[0] = 0
        for i in range(1,amount+1):        
            for j in range(len(coins)):
                if i>=coins[j] :
                    if dp[i]>dp[i-coins[j]] +1:                        
                        dp[i] = dp[i-coins[j]] +1   #本来用的dp[i] = min(dp[i],dp[i-coins[j]] +1),显示超时
        if dp[amount]>amount:#这里因为上面赋值dp初始值为amount了    #或写成 if dp[amount] == float('inf') : #对凑不成硬币，不可行的方案进行判断
            return -1
        else:
            return dp[amount]
        
        
coins = [1,2,5]#coins=[2]
amount = 11
print(Solution().coinChange(coins,amount))    #记得这里是Solution().coinChange，而不是Solution.coinChange

数组组合

也是网易游戏面试考的那题。

题目：输入一个数字summ，输入n个数子，用这n个数有多少种组合成数字summ的方案（每个数字只能用一次）。

思路：背包的方案数问题。并且这个题是一个物品只能用一次的背包，即01背包问题变化的方案数问题。

状态：dp[i]表示用这些数字组成数字i所有的方案数。一直从1到summ。

然后只需要把01背包的思路改动一下，就可以完成这个题了。

01背包第一层循环int i=1…n 表示第一个数到第n个数。

第二层循环int j=summ…1 表示组成的数字。

只需把两层循环里的max（dp[j]，dp[j-w[i]]）改成dp[j]+dp[j-w[i]]即可。

两个for循环，一个从小到大，另一个从小到大，然后以dp[j]=…（求max时）

w=[0,1,2,3]
n=3
summ=6
dp=[0]*(summ+1)
dp[0] = 1
for i in range(1,n+1):
    for j in range(summ,0,-1):
        if j>=w[i]:
            dp[j] = dp[j] + dp[j-w[i]] # dp[j]=不加入第i个物品时重量为dp[j]的方式+加入这次第i个物品，那么之前dp[j-w[i]]的放入方式
 
print(dp[summ])

网易秋招笔试题 - 连续最大和

题目描述
一个数组有 N 个元素，求连续子数组的最大和。例如：[-1,2,1]，和最大的连续子数组为[2,1]，其和为 3
输入描述:
输入为两行。第一行一个整数n(1 <= n <= 100000)，表示一共有n个元素第二行为n个数，即每个元素,每个整数都在32位int范围内。以空格分隔。
输出描述:
所有连续子数组中和最大的值。

只要累加不小于0，就可以继续累加，如果小于0了，从当前位置重新开始。

参考 https://blog.csdn.net/whwan11/article/details/82665784

#include<iostream>
using namespace std;

int main()
{
    int n,i;
    cin>>n;
    int *num=new int[n];

    i=0;
    while(i<n)
    {
        cin>>num[i];
        i++;
    }

    int dp,max_s;

    dp=num[0];
    max_s=dp;
    for(i=1;i<n;i++)
    {
        if(dp<=0)
            dp=num[i];
        else 
            dp+=num[i];

        if(dp>max_s)
            max_s=dp;
    }
    cout<<max_s<<endl;

    return 0;
}

用python写：

def lps(s):
    dp = s[0]
    maxx=dp
    for i in range(1,len(s)):
        if dp<0:
            dp = s[i]
        else:
            dp+=s[i]
        if dp>maxx:
            maxx = dp
    return maxx

#s = input()
s=[-1,2,1]
res = lps(s)
print(res)

最长回文子序列

参考 https://blog.csdn.net/geekmanong/article/details/51056375

str[0…n-1]是给定的字符串序列，长度为n，假设lps(0,n-1)表示序列str[0…n-1]的最长回文子序列的长度。

如果str的最后一个元素和第一个元素是相同的，则有：lps(0,n-1)=lps(1,n-2)+2；例如字符串序列“AABACACBA”，第一个元素和最后一个元素相同，其中lps(1,n-2)表示红色部分的最长回文子序列的长度；

如果str的最后一个元素和第一个元素是不相同的，则有：lps(0,n-1)=max(lps(1,n-1),lps(0,n-2))；例如字符串序列“ABACACB”，其中lps(1,n-1)表示去掉第一元素的子序列，lps(0,n-2)表示去掉最后一个元素的子序列。

 def lps(s,n):
     dp = [[0 for col in range(10)] for row in range(10)]
     
     for i in range(n):
         dp[i][i] = 1
     for i in range(1,n):
         tmp = 0
         #考虑所有连续的长度为i+1的子串，s[j....j+i]  这个很厉害 子串
         for j in range(n-i):
             if s[j] == s[j+i]:
                 tmp = dp[j+1][j+i-1]+2
             else:
                 tmp = max(dp[j + 1][j + i], dp[j][j+i-1])
             dp[j][j+i] = tmp
     return dp[0][n-1]   # 返回字符串str[0...n-1]的最长回文子序列长度
 #s = input()
 s='adbca'
 res = lps(s,len(s))
 print(res)

回文子序列个数

延伸问题，问回文子序列的个数，参考 https://www.cnblogs.com/AndyJee/p/4465696.html

要求：
给定字符串，求它的回文子序列个数。回文子序列反转字符顺序后仍然与原序列相同。例如字符串aba中，回文子序列为"a", “a”, “aa”, “b”, “aba”，共5个。内容相同位置不同的子序列算不同的子序列。

思路：
动态规划思想

对于任意字符串，如果头尾字符不相等，则字符串的回文子序列个数就等于去掉头的字符串的回文子序列个数+去掉尾的字符串的回文子序列个数-去掉头尾的字符串的回文子序列个数；如果头尾字符相等，那么除了上述的子序列个数之外，还要加上首尾相等时新增的子序列个数，1+去掉头尾的字符串的回文子序列个数，1指的是加上头尾组成的回文子序列，如aa，bb等。

因此动态规划的状态转移方程为：

设字符串为str，长度为n，p[i][j]表示第i到第j个字符间的最长子序列的长度（i<=j），则：

状态初始条件：dp[i][i]=1 （i=0：n-1）

状态转移方程：dp[i][j]=dp[i+1][j] + dp[i][j-1] - dp[i+1][j-1] if（str[i]！=str[j]）

dp[i][j]=dp[i+1][j] + dp[i][j-1] - dp[i+1][j-1]+dp[i+1][j-1]+1=dp[i+1][j] + dp[i][j-1]+1 if （str[i]==str[j]）

#include <iostream>
#include <vector>
using namespace std;

int NumOfPalindromeSubSequence(string str){
    int len=str.length();
    vector<vector<int> > dp(len,vector<int>(len));

    for(int j=0;j<len;j++){
        dp[j][j]=1;
        for(int i=j-1;i>=0;i--){
            dp[i][j]=dp[i+1][j]+dp[i][j-1]-dp[i+1][j-1];
            if(str[i]==str[j])
                dp[i][j]+=1+dp[i+1][j-1];
        }
    }
    return dp[0][len-1];
}

int main()
{
    string str;
    int num;
    while(cin>>str){
        num=NumOfPalindromeSubSequence(str);
        cout<<num<<endl;
    }
    return 0;
}