洛谷动态规划题单

于 2024-09-27 18:06:37 发布
阅读量332 收藏 2
点赞数 9
文章标签： 动态规划 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79872524/article/details/142599664
版权

P2196 [NOIP1996 提高组] 挖地雷

https://www.luogu.com.cn/problem/P2196 普及/提高−

这一道题直接用dfs就能做，不需要动态规划

#include<bits/stdc++.h>
using namespace std;
using u32 = unsigned;
#define i128 __int128;
using ll = long long;
using u64 = unsigned long long;
const int inf = 2147483647;
const ll INF = 1e18;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n;
    cin>>n;
    vector<int>a(n+1);
    vector<vector<int>>adj(n+1);
    for(int i=1;i<=n;i++)cin>>a[i];
    for(int i=1;i<=n-1;i++)
    {
        for(int j=i+1;j<=n;j++)
        {
            int x;
            cin>>x;
            if(x)
            {
                adj[i].push_back(j);// 这个是单向边
            }
        }
    }    
    vector<int>ret;
    ll ans=0;
    vector<ll>dp(n+1);
    ll sum=0;
    auto dfs=[&](auto self,int u,int fa,vector<int>&vv)->void{
        if(adj[u].empty())//搜到底部的话如果总和(sum>ans),那么就更新ans和存的路径数组ret
        {
            if(sum>ans){ret=vv;ans=sum;}
            return;
        }
        for(auto v:adj[u])
        {
            if(v==fa)continue;
            vv.push_back(v);
            sum+=a[v];
            self(self,v,u,vv);
            vv.pop_back();
            sum-=a[v];
        }
    };
    for(int i=1;i<=n;i++)
    {
        sum=0;
        vector<int>vv;
        vv.push_back(i);//将路径的第一个点线计算进去
        sum+=a[i];
        dfs(dfs,i,-1,vv);
    }
    for(int i=0;i<ret.size();i++)cout<<ret[i]<<" \n"[i==ret.size()-1];
    cout<<ans<<'\n';
    return 0;    
}

P1434 [SHOI2002] 滑雪

https://www.luogu.com.cn/problem/P1434 普及/提高−

这一题求滑雪的最大路径,我的理解是对每一个点进行dfs, 找到能走到的尽头, 然后回溯从1递增赋值,同时对路径上的每一个点进行标记( vis数组 ), 如果在dfs的过程中遇到已标记的点, 那么就直接回溯, 对这个点进行递增.

#include<bits/stdc++.h>
using namespace std;
using u32 = unsigned;
#define i128 __int128;
using ll = long long;
using u64 = unsigned long long;
const int inf = 2147483647;
const ll INF = 1e18;
int dx[]={1,0,0,-1};
int dy[]={0,1,-1,0};
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n,m;
    cin>>n>>m;
    vector<vector<int>>a(n+1,vector<int>(m+1)),vis(n+1,vector<int>(m+1)),dp(n+1,vector<int>(m+1));
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)cin>>a[i][j];
    }    
    int jishu=0;
    auto dfs=[&](auto self,int x,int y)->void{
        int cnt=0;
        vis[x][y]=1;
        for(int i=0;i<4;i++)
        {
            int xx=x+dx[i],yy=y+dy[i];
            if(xx<1||xx>n||yy<1||yy>m)continue;
            if(a[xx][yy]<=a[x][y])continue;
            cnt++;
            if(vis[xx][yy]){dp[x][y]=max(dp[x][y],dp[xx][yy]+1);continue;}// r如果标记了, 就直接回溯然后递增
            self(self,xx,yy);
            dp[x][y]=max(dp[x][y],dp[xx][yy]+1);
        }
        if(!cnt)dp[x][y]=1;如果无路可通, 说明是最下面那一个点, 就从1开始赋值.
    };
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            if(vis[i][j])continue;//没走过可以走
            dfs(dfs,i,j);
        }
    }
    int maxn=-inf;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)maxn=max(maxn,dp[i][j]);
    }
    cout<<maxn<<'\n'; 
    return 0;    
}

P4017 最大食物链计数

https://www.luogu.com.cn/problem/P4017 普及/提高−

拓扑排序, 在走到每一个链走后一个点时用ret进行累加

#include<bits/stdc++.h>
using namespace std;
using u32 = unsigned;
using ll = long long;
using u64 = unsigned long long;
const int inf = 2147483647;
const ll INF = 1e18;
const int mod=80112002;
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n,m;
    cin>>n>>m;
    vector<vector<int>>adj(n+1);
    vector<int>in(n+1);
    for(int i=1;i<=m;i++)    
    {
        int a,b;
        cin>>a>>b;
        adj[a].push_back(b);
        in[b]++;
    }
    queue<int>q;
    vector<int>sum(n+1);
    for(int i=1;i<=n;i++)
    {
        if(in[i]==0){q.push(i);sum[i]=1;}
    }
    int ret=0;
    while(q.size())
    {
        int shu=q.front();q.pop();
        if(adj[shu].empty())ret+=sum[shu];
        for(auto v:adj[shu])
        {
            sum[v]=(sum[shu]+sum[v])%mod;
            if(--in[v]==0)q.push(v);
        }
    }
    cout<<ret%mod<<'\n';
    return 0;    
}

P1115 最大子段和

https://www.luogu.com.cn/problem/P1115 普及−

#include<bits/stdc++.h>
using namespace std;
using ll = long long; 
const int N=2e5+10;
int arr[N];
int main()
{
    cin.tie(nullptr)->ios::sync_with_stdio(false);
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>arr[i];
    }
    vector<int>dp(n+1);
    for(int i=1;i<=n;i++)
    {
        if(dp[i-1]>0)dp[i]=dp[i-1]+arr[i];
        else dp[i]=arr[i];
    }
    int ret=*max_element(dp.begin()+1,dp.end());
    cout<<ret<<"\n";



    return 0;    
}

P1077 [NOIP2012 普及组] 摆花

https://www.luogu.com.cn/problem/P1077 普及/提高−

这个是多重背包，但是由于每次消耗的都是1，所以看起来比较简单，为了便于理解，这里也附上oiwiki上的多重背包代码

for (int i = 1; i <= n; i++) {
  for (int weight = W; weight >= w[i]; weight--) {
    // 多遍历一层物品数量
    for (int k = 1; k * w[i] <= weight && k <= cnt[i]; k++) {
      dp[weight] = max(dp[weight], dp[weight - k * w[i]] + k * v[i]);
    }
  }
}

#include<bits/stdc++.h>
using namespace std;
using u32 = unsigned;
#define i128 __int128;
using ll = long long;
using u64 = unsigned long long;
const int inf = 2147483647;
const ll INF = 1e18;
const int mod=1e6+7;
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n,m;
    cin>>n>>m;
    vector<int>a(n+1);
    for(int i=1;i<=n;i++)cin>>a[i];
    vector<int>dp(m+1);
    dp[0]=1;
    for(int i=1;i<=n;i++)
    {
        for(int j=m;j>=1;j--)
        {
            for(int k=1;k<=min(a[i],j);k++)
            {
                dp[j]=(dp[j]+dp[j-k])%mod;
            }
        }
    }
    cout<<dp[m]<<'\n';
    return 0;    
}

P3842 [TJOI2007] 线段

https://www.luogu.com.cn/problem/P3842 普及/提高−

#include<bits/stdc++.h>
using namespace std;
using u32 = unsigned;
#define i128 __int128;
using ll = long long;
using u64 = unsigned long long;
const int inf = 2147483647;
const ll INF = 1e18;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n;
    cin>>n;
    vector<vector<int>>dp(n+1,vector<int>(2));// 背包开了两维，第二维如果是0就是线段的左端点，1就是线段的右端点
    dp[0][0]=0,dp[0][1]=0;
    vector<pair<int,int>>v(n+1);
    v[0].first=1,v[0].second=1;
    for(int i=1;i<=n;i++)
    {
        cin>>v[i].first>>v[i].second;
        auto [l,r]=v[i-1];
        auto [ll,rr]=v[i];
        // 每一层的左右两个端点都可以从上一层的左右两个端点递推而来
        dp[i][0]=min(dp[i-1][0]+abs(rr-l)+rr-ll,dp[i-1][1]+abs(rr-r)+rr-ll);
        dp[i][1]=min(dp[i-1][0]+abs(ll-l)+rr-ll,dp[i-1][1]+abs(ll-r)+rr-ll);
    }    
    cout<<min(dp[n][0]+abs(n-v[n].first),dp[n][1]+abs(n-v[n].second))+n-1<<'\n';// 记得还要加上n-1，因为每走一层要+1
    return 0;    
}

P1064 [NOIP2006 提高组] 金明的预算方案

https://www.luogu.com.cn/problem/P1064 普及+/提高

总的来说感觉还是0/1背包，只不过需要分情况，将主键和附件绑定到一起的各种情况分别计算就行了

这个题的决策是五个，分别是：

1.不选，然后去考虑下一个 // 这种情况实操不用考虑，因为一维dp数组直接就相当于继承上一层了，这一种情况默认就已经完成了

2.选且只选这个主件

3.选这个主件，并且选附件1

4.选这个主件，并且选附件2

5.选这个主件，并且选附件1和附件2.

#include<bits/stdc++.h>
using namespace std;
using u32 = unsigned;
#define i128 __int128;
using ll = long long;
using u64 = unsigned long long;
const int inf = 2147483647;
const ll INF = 1e18;
struct node
{
    int v,p,q;
    int jz;
};
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int m,n;
    cin>>m>>n;
    vector<node>v(n+1);
    vector<vector<int>>adj(n+1);
    vector<ll>dp(m+1);
    for(int i=1;i<=n;i++)
    {
        cin>>v[i].v>>v[i].p>>v[i].q;
        v[i].jz=v[i].v*v[i].p;
        if(v[i].q)adj[v[i].q].push_back(i);// 如果不是0的话就把他接到adj[v[i].q]后面
    }    
    for(int i=1;i<=n;i++)
    {
        if(v[i].q)continue;
        for(int j=m;j>=v[i].v;j--)
        {
            dp[j]=max(dp[j],dp[j-v[i].v]+v[i].jz);
            if(adj[i].size()==2)
            {
                if(j>=v[i].v+v[adj[i][0]].v)dp[j]=max(dp[j],dp[j-v[i].v-v[adj[i][0]].v]+v[i].jz+v[adj[i][0]].jz);

                if(j>=v[i].v+v[adj[i][0]].v+v[adj[i][1]].v)dp[j]=max(dp[j],dp[j-v[i].v-v[adj[i][0]].v-v[adj[i][1]].v]+v[i].jz+v[adj[i][0]].jz+v[adj[i][1]].jz);

                if(j>=v[i].v+v[adj[i][1]].v)dp[j]=max(dp[j],dp[j-v[i].v-v[adj[i][1]].v]+v[i].jz+v[adj[i][1]].jz);
                
            }
            else if(adj[i].size()==1)
            {
                if(j>=v[i].v+v[adj[i][0]].v)dp[j]=max(dp[j],dp[j-v[i].v-v[adj[i][0]].v]+v[i].jz+v[adj[i][0]].jz);
            }
        }
        
    }
    cout<<dp[m]<<'\n';
    return 0;    
}
klb326327
关注
蓝桥杯真题（数字三角形详解，洛谷P1236）
02-19
通过解决这类题目，不仅可以加深对动态规划这一核心算法的理解，还能有效提升解决问题的能力。 #### 题目描述与分析 题目要求参赛者编写一个程序来找到一条从数字三角形的顶部到底部的路径，使得路径上的数字之和...
洛谷有题 CSP-J1 CSP-S1 NOIP 第1轮 初赛 真题及模拟题（B）.pdf
03-30
- **NOIP 2008提高组**：题目难度有所增加，包括更复杂的算法应用，如动态规划、贪心算法等。 - **NOIP 2010普及组**：考查了学生对于基础数据结构的理解和运用，比如数组、链表的操作。 - **NOIP 2012提高组**：...
存储洛谷考研复试代码题.zip
03-31
- 动态规划：解决最优化问题的有效方法，如背包问题、最长公共子序列、矩阵链乘法等。 - 回溯法：用于解决组合优化问题，如八皇后问题、N皇后问题、括号生成等。 - 分治法：将大问题分解为小问题求解，如快速排序...
洛谷oj上面的一些题目答案
04-06
1. 题目丰富：洛谷涵盖了从基础算法到高级算法的各种题目，包括排序、搜索、图论、动态规划、字符串处理等多个领域，适合不同水平的学习者。 2. 实时评测：提交代码后，洛谷会立即给出运行结果，包括正确性、运行...
noip模拟题
07-21
1. **基础算法**：排序（如快速排序、归并排序）、搜索（如二分查找、深度优先搜索、广度优先搜索）、图论（如最小生成树、最短路径算法）、动态规划（DP）、回溯法等。 2. **数据结构**：数组、链表、栈、队列、...
atcoder abc372 启发式合并， dp
2201_75845839的博客
09-22 484
现在考虑如何存数据。可以用并查集合并两个集合，并且在合并的时候一定要将小的集合合并到大的集合中去，因为小集合合并到大集合中，最后的集合一定大于小集合元素数量的两倍，因此合并的时间复杂度不会超过logn。思路：判断当前变化的位置对结果是否会产生影响，在询问前先计算有多少ABC, 每次变换位置x前后扫描一下[x - 2, x + 2]范围内是否有ABC，变换前有让cnt --， 变换后有让cnt ++思路：三进制转换，可以参考二进制，先把当前可以加入的最大的3的幂次加入,这样一定可以凑出答案。
【优选算法】（第一篇）
weixin_73861555的博客
09-25 966
这个⽅法是往后我们学习「快排算法」的时候，「数据划分」过程的重要⼀步。如果将快排算法拆解的话，这⼀段⼩代码就是实现快排算法的「核⼼步骤」。
【算法笔记】二分查找 红蓝染色法
weixin_51325964的博客
09-23 791
一个菜鸟的算法笔记
C语言题目之单身狗2
something for nothing的博客
09-22 498
c语言题目之找单身狗2：在一堆数中找到两个只出现过一次数的数
文档矫正算法：DocTr++
Guo_Python的博客
09-23 389
论文提出了一种新的数据处理方式，解决了以前文档矫正只能处理带有边界信息的完整文档，文章通过数据处理定义了三种类型的训练数据。（a）包含完整文档边界，（b）包含部分文档边界，（c）不包含文档边界。算法框架如下：对于任意弯曲的文档，作者首先通过CNN抽取特征，然后通过transformer结构进行编码和解码，最后用Flow Head预测偏移场，用偏移场矫正弯曲图片。
数位dp(算法篇)
hellmorning的博客
09-23 1021
数位dp也就是将动态规划的思想放入到对数的每一位进行，也是一种动态规划的一种，本篇文章将会带大家简单学习一下
全栈项目小组【算法赛】题目及解题
2201_75648436的博客
09-22 462
全栈项目小组【算法赛】
算法打卡：第十一章 图论part05
qq_56221558的博客
09-23 413
代码随想录第55天
【优选算法之前缀和】No.6--- 经典前缀和算法
小沈.的博客
09-23 806
【优选算法之前缀和】No.6--- 经典前缀和算法
python 实现linear discriminant analysis线性判别分析算法
最新发布
luthane的博客
09-26 420
线性判别分析（Linear Discriminant Analysis，简称LDA）是一种用于降维和分类的监督学习算法。它通过最大化类间散度和最小化类内散度来找到最佳投影方向，使得不同类别的数据在新的空间中尽可能分开，同一类别的数据尽可能靠近。LDA的基本思想LDA的基本思想是将多维数据映射到低维空间，同时保留数据之间的类别差异。具体来说，LDA通过计算类内散度矩阵（描述同一类别内部数据的分布情况）和类间散度矩阵（描述不同类别之间的差异），然后求解这两个矩阵的广义特征值问题，找到最佳的投影方向。
代码随想录打卡Day39
weixin_52151595的博客
09-21 395
今天是打家劫舍专题，三道题全都看了讲解，第一次做感觉确实是无从下手。。。不过了解了原理之后代码很快就写出来了。
Trapezoidal Decomposition梯形分解算法（TCD）
qq_35635374的博客
09-21 1157
认知有限，望大家多多包涵，有什么问题也希望能够与大家多交流，共同成长！本文先对**Trapezoidal Decomposition梯形分解算法（TCD）**做个简单的介绍，具体内容后续再更，其他模块可以参考去我其他文章提示：以下是本篇文章正文内容。
力扣2208.将数组各元素总和减半需要最少次数(贪心+堆)
phone15931168209的博客
09-23 248
其实挺简单的 我们只要每次找到最大值减半就行,你没有听错,就是这样,但是我们找最大值可不是每次都遍历数组找最大值,拿太恶心了!nums 的和减小了 33 - 14.75 = 18.25 ，减小的部分超过了初始数组和的一半，18.25 >= 33/2 = 16.5。最终数组为 [5, 4.75, 4, 1] ，和为 5 + 4.75 + 4 + 1 = 14.75。初始 nums 的和为 5 + 19 + 8 + 1 = 33。可以证明，无法通过少于 3 个操作使数组和减少至少一半。
数据结构 ——— 算法的空间复杂度
weixin_55341642的博客
09-23 859
时间是一去不复返的，空间是可以重复利用的
洛谷 P4719 【模板】动态dp【动态dp】
05-22
这道题是一道比较经典的动态规划题目，其实就是一道背包问题。下面简单介绍一下动态规划的思路。 设 $dp[i][j]$ 表示前 $i$ 个物品放入容量为 $j$ 的背包中能得到的最大价值。则状态转移方程为： $$dp[i][j] = \max(dp[i-1][j], dp[i-1][j-v[i]]+w[i])$$ 其中 $v[i]$ 表示第 $i$ 个物品的体积，$w[i]$ 表示第 $i$ 个物品的价值。如果第 $i$ 个物品放不下，则 $dp[i][j] = dp[i-1][j]$。 根据状态转移方程，我们可以写出如下的代码： ```cpp int dp[N][V]; for (int i = 1; i <= n; i++) { for (int j = 0; j <= V; j++) { dp[i][j] = dp[i-1][j]; if (j >= v[i]) { dp[i][j] = max(dp[i][j], dp[i-1][j-v[i]]+w[i]); } } } ``` 其中 $n$ 表示物品数量，$V$ 表示背包容量，$v[i]$ 和 $w[i]$ 分别表示第 $i$ 个物品的体积和价值。 最终答案即为 $dp[n][V]$。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值