当前位置：首页 > news >正文

【动态规划】相关复习

news 来源：原创 2025/5/17 0:28:28

在这里插入图片描述

个人主页：Guiat
归属专栏：我讲你听

在这里插入图片描述

文章目录

1. 动态规划 DP
2. 二维DP
3. 01背包
4. 完全背包（无穷背包）
5. LCS
6. LIS

正文

1. 动态规划 DP

【介绍】

DP（动态规划）全称DynamicProgramming，是运筹学的一个分支，是一种将复杂问题分解成很多重叠的子问题，并通过子问题的解得到整个问题的解的算法。
状态：就是形如dp[ili]=val的取值，其中i，j为下标，也是用于描述、确定状态所需的变量，val为状态值。
状态转移：状态与状态之间的转移关系，一般可以表示为一个数学表达式，转移方向决定迭代或递归方向。
最终状态：也就是题目所求的状态，最后的答案。

【分析步骤】

1. 确定状态，一般为“到第i个为止，xx为j（xx为k）的方案数/最小代价/最大价值”，可以根据数据范围和复杂度来推理。
2. 确定状态转移方程，即从已知状态得到新状态的方法，并确保按照这个方向一定可以正确地得到最终状态。
3. 根据状态转移的方向来决定使用选代法还是递归法（记忆化）。
4 . 确定最终状态并输出。

【题目】数字三角形

【AC_Code】

#include <bits/stdc++.h>
#define IOS ios :: sync_with_stdio(0); cin.tie(0); cout.tie(0); 

using namespace std;
using ll = long long;

const int N = 110; ll a[N][N], dp[N][N];

void solve()
{
    int n; cin >> n; for (int i = 1; i <= n; i ++) for (int j = 1; j <= i; j ++) cin >> a[i][j];
    for (int i = n; i >= 1; i --)
        for (int j = 1; j <= i; j ++) dp[i][j] = a[i][j] + max(dp[i + 1][j], dp[i + 1][j + 1]);
    cout << dp[1][1] << '\n';
}

int main()
{
    IOS; int _ = 1; // cin >> _;
    while (_ --) solve();
        
    return 0;
}

2. 二维DP

【定义】
二维dp就是指dp数组的维度为二维的dp（当然有时候可能会三维四维，或者存在一些优化使得它降维成一维），广义的来讲就是有多个维度的dp，即用于描述dp状态的变量不止一个。

【题目】摆花

【AC_Code】

#include <bits/stdc++.h>
#define IOS ios :: sync_with_stdio(0); cin.tie(0); cout.tie(0); 

using namespace std;
using ll = long long;

const int N = 110, p = 1e6 + 7; ll a[N], dp[N][N];

void solve()
{
    int n, m; cin >> n >> m; for (int i = 1; i <= n; i ++) cin >> a[i];
    dp[0][0] = 1;
    for (int i = 1; i <= n; i ++) for (int j = 0; j <= m; j ++) for (int k = 0; k <= a[i] && k <= j; k ++)
    {
        dp[i][j] = (dp[i][j] + dp[i - 1][j - k]) % p;
    }
    cout << dp[n][m] << '\n';
}

int main()
{
    IOS; int _ = 1; // cin >> _;
    while (_ --) solve();
        
    return 0;
}

3. 01背包

【题目】小明的背包1

【AC_Code】

#include <bits/stdc++.h>
#define IOS ios :: sync_with_stdio(0); cin.tie(0); cout.tie(0); 

using namespace std;
using ll = long long;

const int maxN = 110, maxM = 1010; ll dp[maxN][maxM];

void solve()
{
    int N, V; cin >> N >> V;
    for (int i = 1; i <= N; i ++)
    {
        ll w, v; cin >> w >> v;
        for (int j = 0; j <= V; j ++)
        {
            if (j >= w) dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w] + v);
            else dp[i][j] = dp[i - 1][j];
        }
    }
    cout << dp[N][V] << '\n';
}

int main()
{
    IOS; int _ = 1; // cin >> _;
    while (_ --) solve();
    
    return 0;
}

优化成一维：

#include <bits/stdc++.h>
#define IOS ios :: sync_with_stdio(0); cin.tie(0); cout.tie(0);

using namespace std;

int N, V, w, v, dp[1001];

void solve()
{
	cin >> N >> V;
    for (int i = 1; i <= N; i ++)
    {
        cin >> w >> v;
        for (int j = V; j >= w; j --) dp[j] = max(dp[j], dp[j - w] + v);
    }
    cout << dp[V] << '\n';
}

int main()
{
    IOS; int _ = 1; // cin >> _;
	while (_ --) solve();
        
    return 0;
}

4. 完全背包（无穷背包）

【题目】小明的背包2

【AC_Code】

#include <bits/stdc++.h>
#define IOS ios :: sync_with_stdio(0); cin.tie(0); cout.tie(0); 

using namespace std;

const int maxn = 1e3 + 10; int dp[maxn];

void solve()
{
    int N, V; cin >> N >> V;
    for (int i = 1; i<= N; i ++)
    {
        int w, v; cin >> w >> v;
        for (int j = w; j <= V; j ++) dp[j] = max(dp[j], dp[j - w] + v);
    }
    cout << dp[V] << '\n';
}

int main()
{
    IOS; int _ = 1; // cin >> _;
    while (_ --) solve();
        
    return 0;
}

5. LCS

【简单介绍】LCS（Longest Common Subsequence最长公共子序列）是一个经典的DP模型，时间复杂度绝大多数情况下为O(n ^ 2)。

【求解步骤】

定义状态：设 dp[i][j] 表示序列 X[1 ~ i] 和 Y[1 ~ j] 的 LCS 长度。
状态转移：
- 若 X[i] = Y[j]，则 dp[i][j] = dp[i-1][j-1] + 1。
- 否则，dp[i][j] = max(dp[i-1][j], dp[i][j-1])。
初始化：dp[0][j] = dp[i][0] = 0（空序列的 LCS 长度为 0）。
结果：dp[m][n] 为 LCS 长度（m 和 n 为两序列长度）。

【题目】最长公共子序列

【AC_Code】

#include <bits/stdc++.h>
#define IOS ios :: sync_with_stdio(0); cin.tie(0); cout.tie(0); 

using namespace std;

const int N = 1e3 + 10;
int n, m, a[N], b[N], dp[N][N];

void solve()
{
	cin >> n >> m;
	for (int i = 1; i <= n; i ++) cin >> a[i];
	for (int i = 1; i <= m; i ++) cin >> b[i];
	for (int i = 1; i <= n; i ++) for (int j = 1; j <= m; j ++)
	{
		if (a[i] == b[j]) dp[i][j] = dp[i - 1][j - 1] + 1;
		else dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
	}
	cout << dp[n][m] << '\n';
}

int main()
{
    IOS; int _ = 1; // cin >> _;
	while (_ --) solve();
        
    return 0;
}

6. LIS

LIS（Longest Increasing Subsequence，最长递增子序列）是一类经典的算法问题，旨在找到一个序列中严格递增的最长子序列，是一个经典的DP模型。
例如，序列 [10, 9, 2, 5, 3, 7, 101, 18] 的最长递增子序列为 [2, 3, 7, 101]（长度为4）。

【题目】蓝桥勇士

【AC_Code】

#include <bits/stdc++.h>
#define IOS ios :: sync_with_stdio(0); cin.tie(0); cout.tie(0); 

using namespace std;

const int N = 1e3 + 10; int a[N], dp[N];

void solve()
{
    int n; cin >> n; for (int i = 1; i <= n; i ++) cin >> a[i];
    for (int i = 1; i <= n; i ++)
    {
        dp[i] = 1;
        for (int j = 1; j < i; j ++) if (a[i] > a[j]) dp[i] = max(dp[i], dp[j] + 1);
    }
    int ans = 0; for (int i = 1; i <= n; i ++) ans = max(ans, dp[i]);
    cout << ans << '\n';
}

int main()
{
    IOS; int _ = 1; // cin >> _;
    while (_ --) solve();
        
    return 0;
}