#AcWing：DP系列

最新推荐文章于 2024-04-06 01:09:03 发布
原创 最新推荐文章于 2024-04-06 01:09:03 发布 · 290 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#leetcode

本文深入探讨了动态规划(DP)在解决背包问题、完全背包、多重背包、线性DP、最长上升子序列、最长公共子序列、最短编辑距离等问题上的应用。通过实例解析了DP的状态转移方程，并展示了如何通过优化减少空间复杂度。同时，文章还介绍了区间DP、状态压缩DP在石子合并和蒙德里安梦想问题中的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

好气啊，每次遇到DP我就无可奈何了！听别人讲觉得好神奇，自己就不会做！行！那我今天就不干啥了（除了数据库PPT）就学这个DP，算是一个周末福利吧！
转一下y总写的，由数据范围反推算法复杂度，仔细琢磨吧，多刷题！
本周任务就是DP学习，加上leetcode练习dp
下周是搜索
在这里插入图片描述

1 背包问题

01背包

01背包是背包里面的物品最多只能选择一个，朴素的做法就是二维DP

  • f(i, j)表示只能选前i个物品且体积不超过j的最大值；
  • f(i,j) = max(f(i-1,j), f(i-1,j-v[i]) + w[i])
#include<bits/stdc++.h>
using namespace std;

const int N = 1010;
int V[N], W[N];
int f[N][N];

int main()
{
    int n, v;
    scanf("%d %d", &n, &v);
    for(int i = 1; i <= n; i++)
        scanf("%d %d", &V[i], &W[i]);
    
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= v; j++)
        {
            f[i][j] = f[i - 1][j];
            if(j >= V[i])
                f[i][j] = max(f[i][j], f[i - 1][j - V[i]] + W[i]);
        }
    }
    printf("%d", f[n][v]);
    return 0;
}

然后发现，f[i][j]只与前一个f[i - 1][j]有关，所以可以减少一维数组。但是就是f[j] = max(f[j], f[j - V[i]] + W[i]);需要确保f[j-V[i]]是i-1时候的不是i时候的，所以可以倒着遍历j

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

const int N = 1010;
int V[N], W[N];
int f[N];

int main()
{
    int n, v;
    scanf("%d %d", &n, &v);
    for(int i = 1; i <= n; i++)
        scanf("%d %d", &V[i], &W[i]);
    
    for(int i = 1; i <= n; i++)
    {
        for(int j = v; j >= V[i]; j--)
            f[j] = max(f[j], f[j - V[i]] + W[i]);
    }
    printf("%d", f[v]);
    return 0;
}

完全背包

完全背包就是指物品的数量是无限的，其他一样。
哈哈哈哈哈哈今天学到了一个词，面向yxc编程，哈哈哈哈哈太对了！
在这里插入图片描述最朴素的完全背包，分成k个组，然后取每个组中最大的。

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

const int N = 1010;
int v[N], w[N];
int f[N][N];

int main()
{
    int n, m;
    scanf("%d %d", &n, &m);
    for(int i = 1; i <= n; i++)
        scanf("%d %d", &v[i], &w[i]);
    
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++)
            for(int k = 0; k * v[i] <= j; k++)
                f[i][j] = max(f[i][j], f[i - 1][j - k * v[i]] + k * w[i]);
    
    printf("%d", f[n][m]);
    return 0;
}

经过推导发现可以将其降为二维
在这里插入图片描述

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

const int N = 1010;
int v[N], w[N];
int f[N][N];

int main()
{
    int n, m;
    scanf("%d %d", &n, &m);
    for(int i = 1; i <= n; i++)
        scanf("%d %d", &v[i], &w[i]);
    
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            f[i][j] = f[i - 1][j];
            if(j >= v[i])
                f[i][j] = max(f[i][j], f[i][j - v[i]] + w[i]);
        }
    }
        
    
    printf("%d", f[n][m]);
    return 0;
}

类似于01背包，变成一维。f[j] = max(f[j], f[j - v[i]] + w[i]);变成这个需要f[j - v[i]]是第i个物品时的i，而完全背包正是这样的，所以不用倒序遍历j，即可完成。

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

const int N = 1010;
int v[N], w[N];
int f[N];

int main()
{
    int n, m;
    scanf("%d %d", &n, &m);
    for(int i = 1; i <= n; i++)
        scanf("%d %d", &v[i], &w[i]);
    
    for(int i = 1; i <= n; i++)
    {
        for(int j = v[i]; j <= m; j++)
        {
            f[j] = max(f[j], f[j - v[i]] + w[i]);
        }
    }
        
    
    printf("%d", f[m]);
    return 0;
}

下面是我菜菜的笔记。。。
在这里插入图片描述
在这里插入图片描述

多重背包

多重背包既不是最多一个，也不是无限个，是有给定数量的。
朴素的就和完全背包相同，只需要再把他限制在s[i]之内就行。

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

const int N = 110;

int v[N], w[N], s[N];
int f[N][N];

int main()
{
    int n, m;
    scanf("%d %d", &n, &m);
    for(int i = 1; i <= n; i++)
        scanf("%d %d %d", &v[i], &w[i], &s[i]);
    
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            for(int k = 0; k <= s[i] && k * v[i] <= j; k++)
            {
                f[i][j] = max(f[i][j], f[i - 1][j - k * v[i]] + k * w[i]);
            }
        }
    }
    
    printf("%d", f[n][m]);
    return 0;
}

那个改进版的有点没太懂，脑子现在晕了，好困啊！

分组背包

2 线性DP

线性dp就是指计算的时候大概按照某个顺序计算.

数字三角形

首先是如何表示这个三角形,如何存储,大概就按照下面图上这样.
在这里插入图片描述

  • 状态表示:f[i][j]表示到(i, j)这个点时最大路径和;
  • 状态计算:f[i][j]这个点的最大值只取决于左上和正上那两个点的最大值,即f[i][j] = max(f[i - 1][j - 1], f[i - 1][j]) + a[i][j];
  • 边界:列的左边要初始化,右边也要初始化一下,由于存在负值,初始化为INT_MIN
#include<bits/stdc++.h>
using namespace std;

const int N = 510;
int a[N][N];
int f[N][N];

int main()
{
    int n, ans = INT_MIN;
    scanf("%d", &n);
    
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= i; j++)
            scanf("%d", &a[i][j]);
            
    for(int i = 0; i <= n; i++)
        for(int j = 0; j <= n + 1; j++)
            f[i][j] = INT_MIN;
    
    f[1][1] = a[1][1];
    for(int i = 2; i <= n; i++)
        for(int j = 1; j <= i; j++)
            f[i][j] = max(f[i - 1][j - 1], f[i - 1][j]) + a[i][j];

            
    for(int i = 1; i <= n; i++)
        ans = max(ans, f[n][i]);
        
    printf("%d", ans);
    return 0;
}

也可以从最下面一层向上求,倒序dp,不用考虑边界(下面一层长)

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

const int N = 510;
int a[N][N];
int f[N][N];

int main()
{
    int n, ans = INT_MIN;
    scanf("%d", &n);
    
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= i; j++)
            scanf("%d", &a[i][j]);
            
    
    for(int i = n; i >= 1; i--)
        for(int j = 1; j <= i; j++)
            f[i][j] = max(f[i + 1][j], f[i + 1][j + 1]) + a[i][j];
        
    printf("%d", f[1][1]);
    return 0;
}

也可以不用f,直接在a上进行加和.

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

const int N = 510;
int a[N][N];

int main()
{
    int n, ans = INT_MIN;
    scanf("%d", &n);
    
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= i; j++)
            scanf("%d", &a[i][j]);
            
    
    for(int i = n; i >= 1; i--)
        for(int j = 1; j <= i; j++)
            a[i][j] = max(a[i + 1][j], a[i + 1][j + 1]) + a[i][j];
        
    printf("%d", a[1][1]);
    return 0;
}

最长上升子序列

首先，子序列和字串的概念分清楚。子序列就是从前面排着选就行了，不用非得连着。但是子序列就是得连续。

  • 状态标志：f[i]表示以第i个数结尾的上升子序列中长度的最大值
  • 状态计算：就是前面一个数字（可能是 1, 2, 3,… i - 1）再加上第i个数字，就是再前一个发f[j]上+1

在这里插入图片描述
代码很简单

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

const int N = 1010;
int a[N], f[N];

int main()
{
    int n, ans = INT_MIN;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++)
        scanf("%d", &a[i]);
    
    for(int i = 1; i <= n; i++)
    {
        f[i] = 1;
        for(int j = 1; j <i; j++)
        {
            if(a[i] > a[j])
                f[i] = max(f[i], f[j] + 1);
        }
    }
    for(int i = 1; i <= n; i++)
        ans = max(ans, f[i]);
    printf("%d", ans);
    return 0;
}

下面给出一个nlogn的算法，在上述基础上进行改进。
在这里插入图片描述
图总是裂了，不知道为啥。。。指路一个好的[题解]、(https://www.acwing.com/solution/content/6525/)
堆栈

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

const int N = 100010;
int a[N];
int q[N];

int main()
{
    int n;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++)
        scanf("%d", &a[i]);
    int len = 0;    //目前整个序列中的最长，也就是q中元素个数
    for(int i = 1; i <= n; i++)
    {
        int l = 0, r = len;
        while(l < r)
        {
            int mid = (l + r + 1) / 2;
            if(q[mid] < a[i]) l = mid;
            else r = mid - 1;
        }
        len = max(len, l+ 1);
        q[l + 1] = a[i];
    }
    printf("%d", len);
    return 0;
}

最长公共子序列

有点难，还没有完全理解
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

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

const int N = 1010;
char a[N], b[N];
int f[N][N];

int main()
{
    int n, m;
    scanf("%d %d", &n, &m);
    scanf("%s %s", a + 1, b + 1);
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            f[i][j] = max(f[i - 1][j], f[i][j - 1]);
            if(a[i] == b[j])
                f[i][j] = max(f[i][j], f[i - 1][j - 1] + 1);
        }
    }
    cout << f[n][m];
    return 0;
}

最短编辑距离

在这里插入图片描述
我写的关于增加的普遍理解:

我明白了! 同志们 !
状态表示是指a[1~ i]变成a[1~ j]也就是说已经有了a[1~ i]和b[1~ j]。举个例子:a数组是AGE,b数组是AGEF,此时i=3,j=4（从1开始）怎么变呢？就是在i后面加上一个F，不加F之前不就是应该要求1i和1j-1相等嘛。
我们是受了i和j长度相等的影响，考虑的情况是a数组:AGF, b数组是AGE，此时i=3,j=3,再在i-1后面加上一个E，即要求1~ i和1~ j相等，这是不对的。你在i-1后面加上一个E，那这个序列就变成了AGEF和AGE，那么这个F怎么办呢？所以说是不对的。

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

const int N = 1010;
char a[N], b[N];
int f[N][N];

int main()
{
    int m, n;
    scanf("%d %s", &m, a + 1);
    scanf("%d %s", &n, b + 1);
    
    //初始化
    for(int i = 0; i <= m; i++) f[i][0] = i;
    for(int i = 0; i <= n; i++) f[0][i] = i;
    
    
    for(int i = 1; i <= m; i++)
    {
        for(int j = 1; j <= n; j++)
        {
            f[i][j] = min(f[i - 1][j] + 1, f[i][j - 1] + 1);
            if(a[i] != b[j])
                f[i][j] = min(f[i][j], f[i - 1][j - 1] + 1);
            else
                f[i][j] = min(f[i][j], f[i - 1][j - 1]);
        }
    }
    cout << f[m][n];
    return 0;
}

区间DP

石子合并

在这里插入图片描述

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

const int N = 310;
const int M = 1010;

int a[N];
int s[N];
int f[N][N];

int main()
{
    int n;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
        s[i] = s[i - 1] + a[i];
    }
    
    for(int len = 2; len <= n; len++)
    {
        for(int i = 1; i + len - 1 <= n; i++)
        {
            int l = i, r = i + len - 1;
            f[l][r] = INT_MAX;
            for(int k = i; k < r; k++)
            {
                f[l][r] = min(f[l][r], f[i][k] + f[k + 1][r] + s[r] - s[i - 1]);
            }
        }
    }
    cout << f[1][n];
    return 0;
}

状态压缩DP

蒙德里安的梦想

在这里插入图片描述
在这里插入图片描述
详细题解

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

const int N = 12;
const int M = 1 << N;

typedef long long LL;

LL f[N][M];
bool st[M];
vector<vector<int>> state(M);

int main()
{
    int n, m;
    cin >> n >> m;
    while(n != 0 && m != 0)
    {
        for(int i = 0; i < 1 << n; i++)
        {
            int cnt = 0;
            bool is_vaild = true;
            for(int j = 0; j < n; j++)
            {
                if((i >> j) & 1)
                {
                    if(cnt & 1)//奇数
                    {
                        is_vaild = false;
                        break;
                    }
                    else
                        cnt = 0;
                }
                else
                    cnt++;
            }
            if(cnt & 1)
                is_vaild = false;
            st[i] = is_vaild;
        }
        
        
        
        for(int j = 0; j < 1 << n; j++)
        {
            state[j].clear();
            for(int k = 0; k < 1 << n; k++)
            {
                if((j & k) == 0 && st[j | k])
                    state[j].push_back(k);
            }
        }
        
        memset(f, 0, sizeof f);
        
        f[0][0] = 1;
        
        for(int i = 1; i <= m; i++)
            for(int j = 0; j < 1 << n; j++)
                for(auto k : state[j])
                    f[i][j] += f[i - 1][k];
        cout << f[m][0] << endl;
        cin >> n >> m;
    }
}

最短哈密顿距离

在这里插入图片描述

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

const int N = 20, M = 1 << N;
int a[N][N];
int f[M][N];

int main()
{
    int n;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
        for(int j = 0; j < n; j++)
            scanf("%d", &a[i][j]);
    
    memset(f, 0x3f, sizeof f);
    
    f[1][0] = 0;
    
    for(int i = 0; i < 1 << n; i++)
    {
        for(int j = 0; j < n; j++)
        {
            for(int k = 0; ((i >> j) & 1) && k < n; k++)
            {
                if((i - (1 << j)) >> k & 1)
                {
                    f[i][j] = min(f[i][j], f[i - (1 << j)][k] + a[k][j]);
                }
            }
            
        }
    }
    cout << f[(1 << n) - 1][n - 1];
    return 0;
}
【AcWing】线性DP、区间DP、计数类DP
m0_70948728的博客
07-25 550
线性DP、区间DP、计数类DP
【acwing】数位dp的思路
遍地跑小鸡的博客
06-19 380
偷师acwing，学习数位DP的策略。 引言 数位dp的特点，求解在一个区间内满足某特性的数字的个数。数位dp具有两个特点，第一个，利用前缀和的特点求解区间[left, right]的问题，分别求出【0，left-1】和【0，right】的个数。第二个特点是树，对每一位依次进行分析。 例题 不降数字 给定区间[l, r]求区间内所有是整数，满足低位不小于高位的数值的个数。如，1234，2333. 首先我们定义一个dp[i][j]表示在还有i位的情况下，最高位位j的情况下满足的个数。 显然我们可以知道dp[i
ACwing 2. 01背包问题（DP）
Michael是个半路程序员
10-23 321
文章目录1. 题目2. 解题 1. 题目 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 第 i 件物品的体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出最大价值。 输入格式 第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。 接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。 输出格式 输出一个整数，表示最大价值。 数据范围 0<N,V≤1000 0<vi,wi
低买（acwing）（线性DP）
qq_45604735的博客
06-25 151
题目地址 配套地址 /* 最长下降子序列，求方案数。 预先用n ^ 2 处理完最长下降子序列。 dp(i) 表示前i个构成最长下降子序列 之后用ans(i)表示构成以i结尾的最长下降子序列的方案数， ans(i) += ans(j),且 dp(j) + 1 = dp(i) && a(j) > a(i)，j < i 初始化ans数组，为每一段的起点是初始为1. 注意当价格序列相同，只计算一次。
Acwing-基础算法课笔记之动态规划（线性DP）
weixin_73381974的博客
03-17 1625
给定一个如下图所示的数字三角形，从顶部出发，在每一结点可以选择移动至其左下方的结点或移动至其右下方的结点，一直走到底层，要求找出一条路径，使路径上的数字的和最大。给定一个长度为N的数列A，求数量单调递增的子序列的长度最长是多少。A的任意子序列B可表示为BAk1Ak2AkpBAk1​​Ak2​​...Akp​​，其中k1k2⋯kpk1​k2​⋯kp​。
动态规划 数位dp系列：数字游戏----中专生刷算法
XYY369的博客
04-06 829
图文详解动态规划 数位dp系列：数字游戏----中专生刷算法
acwing动态规划
02-08
AcWing 提供了一系列针对不同难度级别的动态规划(DP)教程，帮助学习者逐步掌握这一重要算法设计技术。这些课程通常从基础概念出发，介绍状态定义、转移方程构建以及边界条件处理等内容[^2]。 #### 经典题目示例 以...
动态规划背包模型acwing
最新发布
02-12
为了帮助学习者巩固所学知识并提高解决问题的能力，AcWing提供了一系列精心设计的练习题目。这些问题覆盖了从简单到复杂的各个层次，并且鼓励用户尝试多种方法去优化自己的解答过程。特别是对于那些希望挑战自我或是...
背包问题acwing
01-13
由于目标是从一系列可能的状态组合中挑选出最佳方案，因此需要特别关注那些形如 `{dp[j], dp[v+j], ...}` 的序列，并从中找出最大值作为新的决策依据[^2]。 #### 01背包问题基础概念 相比之下，最基础也最常见的...
acwing提高课动态规划代码
04-18
本资源“acwing提高课动态规划代码”显然是一系列关于动态规划的编程实践，旨在帮助学习者深入理解和应用这个算法。让我们详细探讨动态规划的概念、应用场景以及C++在实现动态规划时的关键要素。 动态规划（Dynamic...
Acwing提高课-DP(背包模型)
04-06 214
ACwing背包模型
ACwing提高课-DP(区间dp、数位dp)
04-06 396
区间DP、数位DP
ＡＣＷＩＮＧ277. 饼干（ＤＰ，状态输出）
tomjobs的博客
10-12 440
圣诞老人共有M个饼干，准备全部分给N个孩子。 每个孩子有一个贪婪度，第 i 个孩子的贪婪度为 g[i]。 如果有 a[i] 个孩子拿到的饼干数比第 i 个孩子多，那么第 i 个孩子会产生 g[i]*a[i]的怨气。 给定N、M和序列g，圣诞老人请你帮他安排一种分配方式，使得每个孩子至少分到一块饼干，并且所有孩子的怨气总和最小。 输入格式 第一行包含两个整数N,M。 第二行包含N个整数表示g1~gN...
Acwing动态规划计数DP——整数划分
Studying Blog by Bryce Gu
02-24 745
题目： 一个正整数nn可以表示成若干个正整数之和，形如：n=n1+n2+…+nk，其中n1≥n2≥…≥nk,k≥1。 我们将这样的一种表示称为正整数nn的一种划分。 现在给定一个正整数n，请你求出n共有多少种不同的划分方法。 输入格式 共一行，包含一个整数n。 输出格式 共一行，包含一个整数，表示总划分数量。 由于答案可能很大，输出结果请对1e9+7 取模。 数据范围 1≤n≤1000 思路详解： 这道题主要可以用到完全背包的思想： 可以将题意理解为面对一个...
动态规划DP题单 AcWing算法基础课 （详解）
m0_51448653的博客
08-21 1115
目录背包问题背包问题初始化总结AcWing 2. 01背包问题AcWing 3. 完全背包问题AcWing 4. 多重背包问题AcWing 5. 多重背包问题 IIAcWing 9. 分组背包问题 背包问题 背包问题初始化总结 AcWing 2. 01背包问题 #include <bits/stdc++.h> #define endl '\n' #define IOS ios::sync_with_stdio(false); cin.tie(0); cout.tie(0) #define l
ACWing 状态压缩DP （完结撒花 day40
qq_23852555的博客
07-26 336
训练记录
Acwing提高课DP二刷（考研复习）
Alanrookie的博客
04-04 852
DP 1.acwing1010 导弹拦截 题目大意：利用若干组互相独立的单调序列去覆盖原序列 思路：贪心解决 2.AcWing 187. 导弹防御系统 思路：爆搜+贪心 3.AcWing 272. 最长公共上升子序列 思路：dp(i,j)表示a数组从前i个数里面选，b数组从前j个数组里面选，且以bj结尾的最长公共上升子序列的长度，然后根据题意进行状态状态转移。 PS:直接进行状态转移会发现这题会超时，可以先把超时的代码写下来，然后再做等价变形。背包转移的化简与此相同，这种等价变形类的DP可以说很经典了 .
AcWing 单调队列优化DP问题 1088. 旅行问题
皓首不倦 不负少年
08-02 219
import sys sys.stdin = open('data.txt', 'r') ''' 问题做一下转换，把环拆开，组成长度为原来两倍的序列，把每个车站的油量和下一步的距离的差值 作为数组元素的数值，对这个长度是2n的数组求前缀和序列，其实题目要求的就是所有长度是n的滑动 窗口里面前缀和的最小值和窗口开始位置前面一个前缀和的差值的最小值是不是小于0，如果小于0， 说明中间n次移动至少有一次出现了没有油的情况，顺时针和逆时针都做一遍单调队列求滑动窗口最小值 的流程，两次结果有一次是成功的，就可以从.
【Acwing提高】DP·状态机模型
鱼竿钓鱼干
03-15 331
推荐：炒鸡棒的萌新DP题单（大概？） DP·状态机模型知识点题目大盗阿福股票买卖 IV股票买卖 V设计密码修复DNA 知识点 题目 扩展方式 扩展来源 大盗阿福 股票买卖 IV 股票买卖 V 设计密码 修复DNA 题目 大盗阿福 股票买卖 IV 股票买卖 V 设计密码 修复DNA ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值