动态规划

第一题：找零钱问题

 

有数组penny，penny中所有的值都为正数且不重复。每个值代表一种面值的货币，每种面值的货币可以使用任意张，再给定一个整数aim(小于等于1000)代表要找的钱数，求换钱有多少种方法。

给定数组penny及它的大小(小于等于50)，同时给定一个整数aim，请返回有多少种方法可以凑成aim。

分为有该种货币与无该种货币进行讨论，代码如下：

方法一.暴力法

class Exchange {
public:
    int func(vector<int>& penny, int index, int aim) {
        int res = 0;
        if (index == penny.size()) {
            res = aim == 0 ? 1 : 0;
            return res;
        }
        for (int i = 0; i*penny[index] <= aim; ++i) {
            res += func(penny, index+1, aim-i*penny[index]);
        }
        return res;
    }
    int countWays(vector<int> penny, int n, int aim) {
        if (penny.empty()) return 0;
        return func(penny, 0, aim);
    }
};

方法二.暴力记忆法

class Exchange {
public:
    int func(vector<int>& penny, int index, int aim, std::map<int, std::map<int, int>> &tmp_res) {
        int res = 0;
        if (index == penny.size()) {
            res = aim == 0 ? 1 : 0;
            return res;
        }
        for (int i = 0; i*penny[index] <= aim; ++i) {
            if (tmp_res.count(index + 1) && tmp_res[index+1].count(aim-i*penny[index])) {
                res += tmp_res[index+1][aim-i*penny[index]];
            }
            else {
                res += func(penny, index+1, aim-i*penny[index], tmp_res);
            }
        }
        tmp_res[index][aim] = res;//记录下已经求过的路径
        return res;
    }
    int countWays(vector<int> penny, int n, int aim) {
        if (penny.empty()) return 0;
        std::map<int, std::map<int, int>> tmp_res;
        return func(penny, 0, aim, tmp_res);
    }
};

方法三.普通的动态规划方法

class Exchange {
public:
    int countWays(vector<int> penny, int n, int aim) {
        
        vector<vector<int>> dp(n,vector<int>(aim+1,0));//表示0-n种货币拼成aim有多少种方法
        for(int i=0;i<n;++i){
            dp[i][0] = 1;
        }
        for(int i=0;i <= aim;++i){
            if(i % penny[0] == 0)
                dp[0][i]=1;
        }
        for(int i=1;i<n;++i){
           for (int j = 1; j < aim + 1; ++j){
               for (int k = 0; k*penny[i]<= j; ++k) {
                   dp[i][j] += dp[i-1][j-k*penny[i]];
               }
            }  
        }
        return dp[n-1][aim];
    }
};

方法四.改进后的动态规划法

class Exchange {
public:
    int countWays(vector<int> penny, int n, int aim) {
        
        vector<vector<int>> dp(n,vector<int>(aim+1,0));//表示0-n种货币拼成aim有多少种方法
        for(int i=0;i<n;++i){
            dp[i][0] = 1;
        }
        for(int i=0;i <= aim;++i){
            if(i % penny[0] == 0)
                dp[0][i]=1;
        }
        for(int i=1;i<n;++i){
           for (int j = 1; j < aim + 1; ++j)
           {
                if(j - penny[i]>=0)
                 {
                    dp[i][j] = dp[i][j - penny[i]] + dp[i - 1][j];
                }
                else
                {
                    dp[i][j] = dp[i - 1][j];
                }
            }  
        }
        return dp[n-1][aim];
    }
};

 

第二题：台阶问题

 

有n级台阶，一个人每次上一级或者两级，问有多少种走完n级台阶的方法。为了防止溢出，请将结果Mod 1000000007

给定一个正整数int n，请返回一个数，代表上楼的方式数。保证n小于等于100000。

从后往前看，上第n级台阶，只能是从n-1级台阶迈一步或者从n-2级台阶迈二步到达。代码如下：

class GoUpstairs {
public:
    int countWays(int n) {
      
        int *dp = new int [n+1];
        if (n == 0)
            return 0;
        if (n == 1)
            return 1;
        if (n == 2)
            return 2;

        dp[0] = 0;
        dp[1] = 1;
        dp[2] = 2;

        for (int i = 3; i <= n; i++)
            dp[i] = (dp[i-1] + dp[i-2])%1000000007;//防止溢出，结果模1000000007

        return dp[n];
    }
};

 

第三题：矩阵最小路径和

 

有一个矩阵map，它每个格子有一个权值。从左上角的格子开始每次只能向右或者向下走，最后到达右下角的位置，路径上所有的数字累加起来就是路径和，返回所有的路径中最小的路径和。

给定一个矩阵map及它的行数n和列数m，请返回最小路径和。保证行列数均小于等于100.

矩阵任意位置只能是从左边或者从上面到达次位置，代码如下：

class MinimumPath {
public:
    int getMin(vector<vector<int> > map, int n, int m) {
   
        vector<vector<int> > dp(n, vector<int>(m, 0));
        dp[0][0] = map[0][0];

        for (int i = 1; i < n; i++)
            dp[i][0] = dp[i-1][0] + map[i][0];

        for (int j = 1; j < m; j++)
            dp[0][j] = dp[0][j-1] + map[0][j];

        for (int i = 1; i < n; i++){
            for (int j = 1; j < m; j++){
                dp[i][j] = map[i][j] + min(dp[i-1][j], dp[i][j-1]);
            }
        }
        return dp[n-1][m-1];
    }
};

 

第四题：最长上升子序列LIS

 

这是一个经典的LIS(即最长上升子序列)问题，请设计一个尽量优的解法求出序列的最长上升子序列的长度。

给定一个序列A及它的长度n(长度小于等于500)，请返回LIS的长度。

class LongestIncreasingSubsequence {
public:
    int getLIS(vector<int> A, int n) {
        
        int max, i, j;
        vector<int> dp(n, 1);//dp[i]表示以A[i]为末尾的最大上升子序列的长度
        for (i = 1; i < n; i++) {
            max = 1;
            for (j = 0; j < i; j++) {
                if (A[i] > A[j] && dp[j] + 1 > max){//以i结尾的序列的最长子序列可能来自前面任何一个序列
                    max = dp[j] + 1;
                }
            }
            dp[i] = max;
        }
        for (i = 0; i < n; i++)
            if (dp[i] > max)
                max = dp[i];
        return max;
    }
};

第五题：最长公共子序列LCS

 

给定两个字符串A和B，返回两个字符串的最长公共子序列的长度。例如，A="1A2C3D4B56”，B="B1D23CA45B6A”，”123456"或者"12C4B6"都是最长公共子序列。

给定两个字符串A和B，同时给定两个串的长度n和m，请返回最长公共子序列的长度。保证两串长度均小于等于300。

dp[i][j]表示字符串1以i结尾与字符串2以j结尾的最长公共子序列，可能来自dp[i-1][j]，dp[i][j+1]与d[i-1][j-1]，去三者最大值即可，代码如下

class LCS {
public:
    int findLCS(string A, int n, string B, int m) {
       
        vector<vector<int>> dp(n, vector<int>(m, 0));
        int i, j, max;
        for (i = 0; i < n; i++)
        {
            if (A[i] == B[0]){
                while (i < n) {
                    dp[i++][0] = 1;
                }
            }
        }
        for (j = 0; j < m; j++)
        {
            if (A[0] == B[j]){
                while (j < m) {
                    dp[0][j++] = 1;
                }
            }
        }
        for (i = 1; i < n; i++){
            max = 0;
            for (j = 1; j < m; j++){
                max = dp[i-1][j]>dp[i][j-1]?dp[i-1][j]:dp[i][j-1];
                if (A[i] == B[j]) {
                    if (dp[i-1][j-1]+1 > max)
                        max = dp[i-1][j-1] + 1;
                }
                dp[i][j] = max;
            }
        }
        return dp[i-1][j-1];
    }
};

第六题：最长公共连续子串

给出两个字符串（可能包含空格）,找出其中最长的公共连续子串,输出其长度。

与上题不同的是，本题必须要是连续的，dp[i][j]表示字符串1以i结尾与字符串2以j结尾的最长公共连续子串，其值只可能来自于dp[i-1][j-1]+1或者为0，代码如下：

#include <iostream>
#include <vector>
using namespace std;
int main()
{
    string str1, str2;
    int len1, len2;
    int ans;
    while (getline(cin, str1, '\n') ) {
        getline(cin, str2, '\n');
        len1 = str1.length();
        len2 = str2.length();
        ans = 0;
        vector<vector<int>> dp(len1+1, vector<int>(len2+1, 0));
        for (int i = 1; i <= len1; i++){
            for (int j = 1; j <= len2; j++) {
                if (str1[i-1] == str2[j-1]) {
                    dp[i][j] = dp[i-1][j-1] + 1;
                }
                if (dp[i][j] > ans)
                    ans = dp[i][j];
            }
        }
        cout << ans << endl;
    }
    return 0;
}

第7题：01背包问题

 

一个背包有一定的承重cap，有N件物品，每件都有自己的价值，记录在数组v中，也都有自己的重量，记录在数组w中，每件物品只能选择要装入背包还是不装入背包，要求在不超过背包承重的前提下，选出物品的总价值最大。

给定物品的重量w价值v及物品数n和承重cap。请返回最大总价值。

dp[i[j]表示物品为0~i-1，载重为j的情况下，总价值最大。dp[i][j]只可能来自于dp[i-1][j]与d[i-1][j-w[i-1]+v[i-1]，取最大值即可。代码如下：

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

 

第八题：最优编辑问题

 

对于两个字符串A和B，我们需要进行插入、删除和修改操作将A串变为B串，定义c0，c1，c2分别为三种操作的代价，请设计一个高效算法，求出将A串变为B串所需要的最少代价。

给定两个字符串A和B，及它们的长度和三种操作代价，请返回将A串变为B串所需要的最小代价。保证两串长度均小于等于300，且三种代价值均小于等于100。

dp[i][j]表示字符串1的字串0~i-1编辑成字符串2的子串0-j-1最小编辑距离，只可能来自dp[i-1][j]+c1，dp[i][j+1]]+c0，dp[i-1][j-1]，dp[i-1][j-1]+c2，取四者最小值即可。代码如下：

class MinCost {
public:
    int findMinCost(string A, int n, string B, int m, int c0, int c1, int c2) {
        
        vector<vector<int>> dp(n+1, vector<int>(m+1, 0));//第0行与第0列为空
        int i, j;

        dp[0][0] = 0;
        for (i = 1; i <= n; i++)
            dp[i][0] = dp[i-1][0] + c1;
        for (j = 1; j <= m; j++)
            dp[0][j] = dp[0][j-1] + c0;
        for (i = 1; i <= n; i++){
            for (j = 1; j <= m; j++){
                int a, b, c;
                a = dp[i-1][j] + c1;
                b = dp[i][j-1] + c0;
                if (A[i-1] == B[j-1])
                    c = dp[i-1][j-1];
                else
                    c = dp[i-1][j-1] + c2;
                dp[i][j] = c < min(a, b)?c:min(a,b);
            }
        }
        return dp[n][m];
    }
};