【動態規劃】經典題目小結（切割鋼條、最長公共子序列、揹包、硬幣找零、數組組合、連續最大和、最長迴文子序列）

切割鋼條

參考《算法導論》和 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]的最長迴文子序列的長度。

1. 如果str的最後一個元素和第一個元素是相同的，則有：lps(0,n-1)=lps(1,n-2)+2；例如字符串序列“AABACACBA”，第一個元素和最後一個元素相同，其中lps(1,n-2)表示紅色部分的最長迴文子序列的長度；

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;
}