简单DP（动态规划）

DP问题核心

0-1背包问题

01背包问题

二维数组

dp[i][j]:表示所有选法集合中,只从前i个物品中选,并且总体积不大于j的选法的集合,它的值是这个集合中每一个选法的最大值。

01背包问题选择方法的集合可以分成2种：
①不选第i个物品，并且总体积不大于j的集合所达到的最大值:f[i-1][j]
②选择1~i个物品，并且总体积不大于j的集合所达到的最大值f[i][j]

对于第②种情况我们很难计算，因此需要思考从另一个角度解决问题。当选择1 ~i个物品，总体积不大于j的集合的最大值可以转化为，选择1~i-1个物品，总体积不大于j-V[i]的集合+最后一个物品的价值，即dp[i-1][j-V[i]]+w[i]。

#include <bits/stdc++.h>
using namespace std;

const int N = 1010;
int n, m;
int v[N], w[N], dp[N][N];

int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n; i++) cin >> v[i] >> w[i];
    
    for (int i = 1; i <= n; i++) //从前i个物品中选
    {
        for (int j = 1; j <= m; j++) //总体积不大于j
        {
            dp[i][j] = dp[i - 1][j]; //先继承自上一层
            
            //如果j>=第i个物品的体积
            if (j >= v[i]) dp[i][j] = max(dp[i][j], dp[i - 1][j - v[i]] + w[i]);
        }
    }
    
    cout << dp[n][m] << endl;
    
    return 0;
}

一维数组滚动优化

因为在二维数组中，dp[i]只取决于上一层dp[i-1]，所以可以使用一维数组滚动优化。

使用一维数组需要倒过来循环递推，因为在每一轮更新之前，这一维数组中的值表示的是原二维数组中上一层的值；而j-v[i]肯定在j的左边，可以查看它左边的值来从右到左更新。即dp[j]相当于dp[i-1][j]，dp[j-v[i]相当于dp[i-1][j-v[i]]。
状态转移方程为dp[j] = max(dp[j], dp[j - v[i]] + w[i])。

#include <bits/stdc++.h>
using namespace std;

const int N = 1010;
int n, m; //物品数量和背包容积
int v, w, dp[N];

int main()
{
    cin >> n >> m;

    //遍历每个物品
    for (int i = 1; i <= n; i++)
    {
        cin >> v >> w;
        //倒过来循环
        for (int j = m; j >= v; j--) //循环到j >= w就可以了
        {
            //讨论每个物品选和不选两种状态
            dp[j] = max(dp[j], dp[j - v] + w);
        }
    }
    
    cout << dp[m] << endl;
    
    return 0;
}

摘花生

摘花生

#include <bits/stdc++.h>
using namespace std;

const int N = 110;
int t;
int m[N][N], dp[N][N];

int main()
{
    cin >> t;
    while (t--)
    {
        int r, c;
        cin >> r >> c;
        for (int i = 1; i <= r; i++)
        {
            for (int j = 1; j <= c; j++) cin >> m[i][j];
        }
        
        for (int i = 1; i <= r; i++)
        {
            for (int j = 1; j <= c; j++)
            {
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) + m[i][j];
            }
        }
        
        cout << dp[r][c] << endl;
    }
    
    return 0;
}

最长上升子序列

#include <bits/stdc++.h>
using namespace std;

const int N = 1010;
int n, res = 0;
int a[N], f[N]; //f[i]为以a[i]结尾的最长子序列长度

int main()
{
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> a[i];
    
    for (int i = 1; i <= n; i++)
    {
        f[i] = 1; //以a[i]结尾，长度至少都为1
        
        //遍历a[i]前面的数
        for (int j = 1; j < i; j++)
        {
            //要取max，因为前面更新的f[i]可能比现在的f[j] + 1大
            if (a[j] < a[i]) f[i] = max(f[i], f[j] + 1);
        }
        
        //答案为所有f[i]的最大值，而不是f[n]
        res = max(res, f[i]);
    }
    
    cout << res << endl;
    
    return 0;
}

地宫取宝

地宫取宝
四维