简单dp问题汇总

简单dp问题总共分为四类：找钱问题，01背包问题，最长公共子序列问题，最长递增子序列问题

------------------------------------------------------------------------------------------------------------------------------------------

找钱问题

这类问题是dp中最基础的问题，其形式是最外层循环为钱的种类，第二层是钱的金额，最末层是用多少数量的钱实现

但是核心是建立在后续能用前面的值推出的基础上。

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

j表示用多少张钱，k表示目前的金额

这种问题要先知道可用的钱币是什么，然后先把他存在数组里

#include <iostream>
#include <cstring>
using namespace std;
int money[5] = { 1,5,10,25,50 };
long long int dp[300][300] = {0};
int ans[300] = {0};
int main()
{
        int n;
        memset(dp, 0, sizeof(dp));
        dp[0][0] = 1;//切记是从dp[0][0]开始的
        for (int i = 0; i < 5; i++)
        {
            for (int j = 1; j <= 100; j++)
            {
                for (int k = money[i]; k <252; k++)//之前开太大了，爆栈
                {
                    dp[j][k] = dp[j][k] + dp[j - 1][k - money[i]];
                    
                }
            }
        }

        for (int i = 0; i <252; i++)
        {
            ans[i] = 0;
            for (int j = 0; j <= 100; j++)
            {
                ans[i] += dp[j][i];
            }
        }
        while (cin >> n) cout << ans[n] << endl;
        return 0;
}

------------------------------------------------------------------------------------------------------------------------------------------

0/1背包问题

这问题核心就是控制背包容量，然后问当前物品装还是不装的问题

纵向是第几个物品

横向是背包容量

 dp[j][k] = max(dp[j - 1][k], dp[j - 1][k - bone[j].volume] + bone[j].value);

不装就和前一个情况一样，装就要在当前背包容量减去所要装的骨头体积的情况下再加上此骨头的价值

 附加：如果背包的数为小数，比如两位小数，则对每个数*100，把他提升为整数问题（hdu1864）

#include <cstdlib>
#include <cctype>
#include <iterator>
#include <vector>
#include <cstring>
#include <cassert>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#define ll long long
#define INF 0x3f3f3f3f
#define ld long double
const ld pi = acos(-1.0L), eps = 1e-8;
using namespace std;
int dp[1010][1010];
struct Bone
{
    int value, volume;
};
Bone bone[1010];
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++)
    {
        memset(dp, 0, sizeof(dp));
        int num, volume;
        cin >> num >> volume;
        for (int j = 1; j <= num; j++) cin >> bone[j].value;
        for (int j = 1; j <= num; j++)cin >> bone[j].volume;

        for (int j = 1; j <= num; j++)
        {
            for (int k = 0; k <= volume; k++)
            {
                if (bone[j].volume > k)dp[j][k] = dp[j - 1][k];//如果当前骨头都比被背包大的话，那肯定不能放进去的
                else dp[j][k] = max(dp[j - 1][k], dp[j - 1][k - bone[j].volume] + bone[j].value);
            }
        }

        cout << dp[num][volume] << endl;
    }
}

------------------------------------------------------------------------------------------------------------------------------------------

最长公共子序列问题

感觉这个可以背下来

遍历一下，如果元素相同，就找dp[i-1][j-1]的那个值+1；

否则就找dp[i][j-1]和dp[i-1][j]中最大的

#include <iostream>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <string>
using namespace std;
int dp[1005][1005];
string s1, s2;
int main()
{

    while (cin >> s1 >> s2)
    {
        memset(dp, 0, sizeof(dp));
        for (int i = 1; i <= s1.size(); i++)
        {
            for (int j = 1; j <= s2.size(); j++)
            {
                if (s1[i - 1] == s2[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[s1.size()][s2.size()] << endl;
    }
}

------------------------------------------------------------------------------------------------------------------------------------------

最长递增子序列

用两个循环定位

第一个循环定位当前值i

第二个循环依次循环j从开始到当前值，只要该值比当前固定的值（第一层循环）小，

那么就检查以它为结尾的最长递增子序列长度是多少，找出最长的那个子序列长度，

dp[i] = maxi + 1;

#include <iostream>
using namespace std;
int st[10000];
int dp[10000] = { 0 };
int main()
{
    int n;
    cin >> n;
    for (int i = 1; i<=n; i++) cin >> st[i];
    dp[1] = 1;//第一个数最长只能为1
    int ans = 1;
    for (int i = 2; i <= n; i++)
    {
        int maxi = 0;
        for (int j = 1; j < i; j++)
        {
            if (dp[j] >maxi &&st[j]>st[i]) maxi = dp[j];
        }
        dp[i] = maxi + 1;//如果该数前面的数都不满足，那么他的长度就是1，从他自己开始
        if (dp[i] > ans) ans = dp[i];//找出最大的
    }
    cout << ans << endl;
}

 优化：

可以添加一个辅助数组，来存最长递增子序列

辅助数组先存入原数组的第一个，之后依次遍历原数组的每一个值

如果原数组的当前遍历值大于辅助数组的最后一个值，那么当前遍历值直接加入辅助数组，更新辅助数组的最后一个值

如果原数组的当前遍历值小于等于辅助数组的最后一个值，那么替换辅助数组中第一个大于等于该遍历值的值

比如原数组 1 3 6 5

那么辅助数组依次为 1/1,3/1,3,6/1,3,5

最后最长递增子序列的长度即为辅助数组的大小

附个题目：http://acm.hdu.edu.cn/showproblem.php?pid=1257

代码：

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
int num[100010],arr[100010];
int main()
{
    int n;
    while (cin >> n)
    {
        memset(arr, 0, sizeof(arr));
        for (int i = 1; i <= n; i++)
        {
            cin >> num[i];
        }
        arr[1] = num[1];
        int len = 1;
        for (int i = 2; i <= n; i++)
        {
            if (num[i] > arr[len])
            {
                len++;
                arr[len] = num[i];
            }
            else
            {
                int j = lower_bound(arr+ 1, arr + len + 1, num[i]) - arr;
                arr[j] = num[i];
            }
        }
        cout << len << endl;
    }
}