动态规划入门

基础dp都是经典例题，非常直观，易于理解。

硬币问题

HDU 2069.

暴力法

可以组个枚举各个面值的硬币的个数，判断每种情况是否合法。
枚举量是s/50s/25s/10s/5s/1次会超时

动态规划法

定义一个dp[i][j]数组建立一个转移矩阵
其中，横向是金额，纵向是硬币数
矩阵dp[i][j]的含义是用j个硬币实现金额i的方案数量。
例如dp[6][2]=1，表示用两个硬币凑出6分钱，只有一种方案，即5分+1分

“状态转移”的特征是用矩阵前面的状态dp[i][j]能推算出后面状态的值。
第一步：只用1分硬币实现
初始化：dp[0][0]=2，其他为0，定义int type [5]={1,5,10,25,50};为5种硬币的面值。
从dp[0][0]开始，可以推到后面的状态。例如dp[1][1]是dp[0][0]进行“金额+1、硬币数量+1”后的状态转移。转移后组合方案数量不变。即dp[1][1]=dp[0][0]=1;
还要考虑dp[1][1]原有的方案数，递推关系式则为：

dp[1][1]=dp[1][1]+dp[0][0]=dp[1][1]+dp[1-1][1-1]=0+1=1;

即dp[1][1]=dp[1][1]+dp[1-type[0]][1-1];

再加上剩余硬币，继续进行组合
得出状态转移方程为

dp[i][j]=dp[i][j]+dp[i-typep[k]][j-1],k=2,3,4;

总结上述过程，每个状态dp[i][j]都可以根据它前面已经算出的状态进行推导，
总复杂度为O(kmn)，k是不同面值硬币的个数，m和n是矩阵的大小。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
#include<string>

using namespace std;

int dp[251][101] = {0};//第i个硬币有j的钱的方案
int coin[5] = {1,5,10,25,50};//不同的金币数

void solve() {
     dp[0][0] = 1;
     for (int i = 0; i < 5; i++) //对不同的金币数进行遍历
         for(int j=1;j<101;j++)
             for (int k = coin[i]; k < 251; k++) {
                 dp[k][j] += dp[k-coin[i]][j-1];
             }
}

int main() {
    int s;
    int ans[251] = {0};
    solve();
    for (int i = 0; i < 251; i++) {
        for (int j = 0; j < 101; j++) {
            ans[i] += dp[i][j];
        }
    }
    while (cin >> s) {
        cout << ans[s] << endl;
    }
    return 0;
}

0/1 背包

洛谷 P2871 [USACO07DEC]Charm Bracelet S .

与上一题思路基本相同

这一题引进一个滚动数组（二维数组内存占用大），从每一个物品开始，对第i个物品判断放与不放：放第i件物品之后的总价值与放之前的总价值进行比较；

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
#include<string>

using namespace std;

#define max(a,b) a > b ? a : b
int dp[12881] = { 0 };
int v[3403] = { 0 };
int w[3403] = { 0 };

int main() {
    int m, n;
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        scanf("%d%d", &w[i], &v[i]);
    }
    for (int i = 1; i <= n; i++) {
        for (int j = m; j >= w[i]; j--) {
            dp[j] = max(dp[j], dp[j - w[i]] + v[i]);//用滚动数组从后往前计算
        }
    }
    /*for (int i = 0; i < m; i++) {
        cout << dp[i] << " ";
   }*/
    cout << dp[m];
    return 0;
}

最长公共子序列

HDU 1159.

先确定一个序列里面的一个元素，与另一个序列里面所有元素进行比较是否相同，如果相同就在原先基础上+1，即

dp[i][j]=dp[i-1][j-1]+1;

否则dp[i][j]为之前序列的最大值，即

dp[i][j]=max(dp[i][j-1], dp[i-1][j] )

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
#include<string>

using namespace std;

#define max(a,b) a > b ? a : b
#define min(a,b) a > b ? b : a

int dp[1005][1005] = { 0 };
string str1, str2;

int main() {
    while (cin >> str1 >> str2) {
        memset(dp, 0, sizeof(dp));
        for (int i = 1; i <= str1.size(); i++) {
            for (int j = 1; j <= str2.size(); j++) {
                if (str1[i - 1] == str2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                }
                else {
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        cout << dp[str1.size()][str2.size()] << endl;
    }

    return 0;
}