动态规划-经典题型

最少找零数

给定面值为v[0], v[1]…v[n-1]元的硬币若干，如何用最少的硬币凑够total元？

状态：dp[i]表示凑够 i 元需要的最少硬币数

状态转移方程：dp[i] = min { dp[ i-v[j] ]+1}，其中i >= v[j]，j=0..n-1。

const int maxn = 100, INF = 1 << 27;

void dp_coin() //动态规划求最少找零数量
{
    int n, v[100], dp[1000]; //v[i]表示币值，dp[i]表示凑够i元需要的最少硬币数
    cin >> n;
    for (int i = 0; i<n; ++i)
        cin >> v[i];
    int total;
    cin >> total;
    //状态转移方程：dp[i] = min{dp[i-v[j]]+1 | i >= v[j]}
    fill(dp, dp+1000, INF); //初始化为INF
    dp[0] = 0; //初始状态
    for(int i = 1; i <= total; ++i)
    {
        for (int j = 0; j < n; ++j) //遍历币值
        {
            if (i >= v[j] && dp[i-v[j]] + 1 < dp[i])
                dp[i] = dp[i-v[j]] + 1;
        }
        cout << i << " yuan need " << dp[i] << " coins" << endl;
    }
} 

---

最长递增子序列（LIS）

给出N个数a[0], a[1]…a[n-1]，求出最长递增（或非降）子序列的长度。

状态：dp[i]表示前i个数中，以a[i]结尾的最长公共子序列的长度。

状态转移方程：dp[i] = max{1, dp[j]+1}, 其中j < i且a[j] < a[i]。

void dp_LIS() //动态规划求最长递增子序列长度
{
    int n, a[100], dp[100];
    cin >> n;
    for (int i = 0; i<n; ++i)
        cin >> a[i];
    //状态转移方程：dp[i] = max{1, dp[j]+1}, 其中j<i且a[j]<a[i]
    int maxlen = 1; //LIS长度
    for (int i = 0; i < n; ++i)
    {
        dp[i] = 1; //默认为1
        for (int j = i; j>=0; --j) //向前遍历，找到比自己小的数a[j]
        {
            if (a[j] < a[i] && dp[j]+1 > dp[i]) //加在a[j]后的子序列更长
                dp[i] = dp[j]+1;
        }
        if (dp[i] > maxlen) maxlen = dp[i];
    }
    cout << maxlen << endl;
}

---

最长公共子序列（LCS）

状态：dp[i][j]表示a[0..i-1]和b[0..j-1]的LCS的长度

状态转移方程：

char dir[101][101]; //记录方向用于打印
char ans[100]; //存放LCS的结果
int cnt = 0;

void print_LCS(int i, int j, const string &a)
{
    if (i == 0 || j == 0)
    {
        for (int i = cnt-1; i>=0; --i) //输出LCS
            cout << ans[i];
        cout << endl;
        return;
    }
    if (dir[i][j] == 'q') //出现相同字符，向左上角回溯
    {
        ans[cnt++] = a[i-1];
        print_LCS(i-1, j-1, a);
    }
    else if (dir[i][j] == 'w') //向上边回溯
        print_LCS(i-1, j, a);
    else if (dir[i][j] = 'a') //向左边回溯
        print_LCS(i, j-1, a);
}

void dp_LCS() //动态规划求最长公共子序列长度
{
    string a,b;
    cin >> a >> b;
    int dp[101][101];
    fill(dp[0], dp[0]+101*101, 0);
    //a竖着放作为行，b横着放作为列，注意空出第0行和第0列
    for (int i = 1; i <= a.length(); ++i)
    {
        for (int j = 1; j <= b.length(); ++j)
        {
            if (a[i-1] == b[j-1]) //-1是因为字符串下标从0开始，而这里填dp矩阵从(1,1)开始
            {
                dp[i][j] = dp[i-1][j-1] + 1;
                dir[i][j] = 'q'; //左上角
            }
            else if (dp[i-1][j] >= dp[i][j-1])
            {
                dp[i][j] = dp[i-1][j];
                dir[i][j] = 'w'; //上一格
            }
            else if (dp[i-1][j] < dp[i][j-1])
            {
                dp[i][j] = dp[i][j-1];
                dir[i][j] = 'a'; //左一格
            }
            cout << dp[i][j] << ' ';
        }
        cout << endl;
    }
    cout << "Longest Common Subsequence: " << endl;
    cout << "Length: " << dp[a.length()][b.length()] << endl;
    cout << "Results: ";
    print_LCS(a.length(), b.length(), a);
}