c++動態規划dp算法題

問題1：找硬幣，換錢的方法

輸入：

• penny數組代表所有貨幣的面值，正數不重復
• aim小於等於1000，代表要找的錢

輸出：
換錢的方法總數

解法1：經典dp，空間復雜度O（n*aim）

class Exchange {
public:
    int countWays(vector<int> penny, int n, int aim) {
        if (penny.empty()||n == 0)
            return 0;
        vector<vector<int> > dp(n,vector<int>(aim+1)); //二維數組dp
        for (int i = 0;i < n;i++) {
            dp[i][0] = 1;
        }
        for (int j = 1;j < aim+1;j++) {
            dp[0][j] = j%penny[0] == 0?1:0;  //只需要算dp[0][j]
        }   
         
        for (int i = 1;i < n;i++) {
            for (int j = 1;j < aim+1;j++) {
                dp[i][j] = (j-penny[i]) >= 0?(dp[i-1][j] + dp[i][j-penny[i]]):dp[i-1][j];   //這是關鍵，不用管penny【i】到底使用了幾次，直接減去1次使用就好                
            }
        }
        return dp[n-1][aim];
    }
};

　　解法2：與上面的問題一樣，只不過在求dp時只使用1維數組來做；使用迭代，時間復雜度一樣：

class Exchange {
public:
    int countWays(vector<int> penny, int n, int aim) {
        vector<int> dp(aim + 1);
        for (int i = 0; i <= aim; i++)
            if (i % penny[0] == 0)
                dp[i] = 1;
 
        for (int i = 1; i < n; i++)
            for (int j = 1; j <= aim; j++)
                if ( j >= penny[i]) //條件，如果不滿足就直接等於上輪的結果，不用做修改
                    dp[j] += dp[j - penny[i]];
        return dp[aim];
    }
};

問題2：跳台階問題：

其實是斐波那契問題，f(n)=f(n-1)+f(n-2)

#include <iostream>
using namespace std;
int main(){
	int step;
	while(cin>>step){
		vector<int> dp(2,1); //初始化賦值
		dp[1]=2;
		int temp;
		for(int i=3;i<=step;i++){
			temp=dp[0];
            dp[0]=dp[1];
            dp[1]=dp[1]+temp;
		}
		if(step==1) dp[1]=1;;
		cout<<dp[1]<<endl;
	}
	return 0;
}

問題3：走矩陣，求路勁最小和，或者是求整個路徑

• n×m的map，則 f(n,m)=min(f(n-1,m),f(n,m-1))+map[n][m]；
• 由於這里和問題1類似，可以只用到一個一維數組求解；

class MinimumPath {
public:
    int getMin(vector<vector<int> > map, int n, int m) {
        vector<int> dp(m,0);
        dp[0] = map[0][0];
        for (int i = 1,j = 0;i < m;i++,j++) {
            dp[i] = map[0][i]+dp[j];
        }
         
        for (int i = 1;i < n;i++) {
            dp[0] += map[i][0];     //不能忘了dp[0]的更新
            for (int j = 1;j < m;j++) {
                dp[j] = min(dp[j],dp[j-1])+map[i][j]; //如果求路徑，則在這里記錄，需要額外存儲空間
            }
        }
        return dp[m-1];
    }
};

問題4：最長上升子序列問題（LIS）

解法：O（N方）用dp數組的dp[i]記錄下以A[i]結尾的遞增子序列中最長的長度，計算dp[i+1]時，遍歷A[0~i]找到比A[i+1]小的元素，再比較與這些元素對應的dp數組中的值，找到最大的一個再加1，賦值給dp[i+1]。

class LongestIncreasingSubsequence {
public:
    int getLIS(vector<int> A, int n) {
        if (A.empty()||n == 0)
            return 0;  
        vector<int> dp(n,0);
        dp[0] = 1;
        int resMax = 0;
        for (int i = 1;i < n;i++) {
            int tempMax = 0;
            for (int j = 0;j < i;j++) {
                if (A[i] > A[j])
                    tempMax = max(tempMax,dp[j]);
            }
            dp[i] = ++tempMax;
            resMax = max(resMax,dp[i]);  //記錄最大的上升子序列長度，因為當前i可能並不在最長上升子序列中
        }
        return resMax;
    }
};

• 如上的實現復雜度為N方，可以增加歸納的假設，增加b[k]存儲長度為k最長子序列最小結尾元素，那么可以利用二分查找，使用logn查找到插入點，對於每次比較，要么直接比較b【k】比它大直接k+1，更新b【k+1】，要么二分查找到位置，更新b【j】，所以最終復雜度為nlogn（如果數據量大的話，使用該算法較好）
• 參考 https://blog.csdn.net/netown_ethereal/article/details/24010381

 

問題5：最長公共子序列長度（LCS）

上圖可以看出使用了斜側的比較，所以不能再使用1維數組了

class LCS {
public:
    int findLCS(string A, int n, string B, int m) {
         if (A.empty()||n==0||B.empty()||m==0)
            return 0;
        vector<vector<int> > dp(n,vector<int>(m));
         //下面是兩個for的初始化，當出現第一個相等的時，后面的都直接賦值為1；
        for (int i = 0;i < m;i++) {
            if (A[0] == B[i]) {
                for (int j = i;j < m;j++)
                    dp[0][j] = 1;
                break ;
            }               
        }
        for (int i = 0;i < n;i++) {
            if (B[0] == A[i]) {
                for (int j = i;j < n;j++)
                    dp[j][0] = 1;
                break ;
            }               
        }
        for (int i = 1;i < n;i++) {
            for (int j = 1;j < m;j++) {
                if (A[i] == B[j])
                    dp[i][j] = dp[i-1][j-1]+1;
                else
                    dp[i][j] = max(dp[i-1][j],dp[i][j-1]);
            }
        }
        return dp[n-1][m-1];
    }
};

上面的方法中初始化第一行和第一列有點麻煩，增加了額外的語句，可以增加數組一行和一列來優化代碼：

class LCS {
public:
    int findLCS(string A, int n, string B, int m) {         
        vector<vector<int> > dp(n+1,vector<int>(m+1,0)); 
        for (int i =1;i<=n ;++i){             
            for (int j=1; j<=m; ++j){
                if (A[i-1] == B[j-1]){
                    dp[i][j]  = dp[i-1][j-1]+1; //第1行也可以照此直接初始化
                }
                else {
                    dp[i][j] = max( dp[i-1][j] ,dp[i][j-1]);
                }                 
            }
        }
        return dp[n][m];
    }
};

問題6：背包

• N件物品，價值記錄在數組V，重量記錄在數組W，背包總重量最大為cap，要求總價值最大；

class Backpack {
public:
    int maxValue(vector<int> w, vector<int> v, int n, int cap) {
        if (w.empty()||v.empty()||n==0||cap==0)
            return 0;
        vector<vector<int> > dp(n,vector<int>(cap+1));
         
        for (int j = 1;j < cap+1;j++) {
            dp[0][j] = w[0] <= j?v[0]:0;
        }
        for (int i = 0;i < n;i++) {
            dp[i][0] = 0;
        }
         
        for (int i = 1;i < n;i++) {
            for (int j = 1;j < cap+1;j++) {
                if (w[i] > j)
                    dp[i][j] = dp[i-1][j];
                else
                    dp[i][j] = max(dp[i-1][j],v[i]+dp[i-1][j-w[i]]); //由於該問題每個物品最多只能放1件，如果不限制個數的話，則在這里修改條件
            }
        }
        return dp[n-1][cap];
    }
};

　　由於沒有用到斜側的比較，所以可以使用1維的數組：

class Backpack {
public:
    int maxValue(vector<int> w, vector<int> v, int n, int cap) {
        if (w.empty()||v.empty()||n==0||cap==0)
            return 0;
        vector<int> dp(cap+1,0);        
        for (int i = 0;i < n;i++) {
             vector<int> last(dp);
            for (int j = 1;j < cap+1;j++) {
                dp[j] = j < w[i]?last[j]:max(last[j],v[i]+last[j-w[i]]);                
            }
        }
        return dp[cap];
    }
};