zzu vjudge暑假训练day3--动态规划

已于 2024-09-11 12:14:11 修改
阅读量465 收藏 3
点赞数 10
文章标签： 动态规划 算法
于 2024-09-11 12:13:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79872524/article/details/142136401
版权

zzu vjudge暑假训练day3–动态规划

B最长上升子序列

https://www.luogu.com.cn/problem/B3637

#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;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n;
    cin>>n;
    vector<int>a(n+1),dp(n+1,1);
    for(int i=1;i<=n;i++)cin>>a[i];   
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<i;j++)
        {
            if(a[j]<a[i])// 遍历i之前的dp数组，如果a[j]<a[i],更新dp[j];
            dp[i]=max(dp[i],dp[j]+1);
        }
    }
    cout<<*max_element(dp.begin()+1,dp.end())<<'\n';
    return 0;    
}

D装箱问题

https://www.luogu.com.cn/problem/P1049

这一题是个完全背包问题

#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;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n,v;
    cin>>v>>n;
    vector<int>a(n+1),dp(v+1);
    for(int i=1;i<=n;i++)cin>>a[i];
    for(int i=1;i<=n;i++)
    {
        for(int j=v;j>=1;j--)
        {
            if(j>=a[i])
            dp[j]=max(dp[j],dp[j-a[i]]+a[i]);
        }
    }
    cout<<v-dp[v]<<'\n';

    return 0;    
}

E - 榨取kkksc03

https://www.luogu.com.cn/problem/P1855

这一题是个双重背包，开二维dp数组就行了

#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;
struct node
{
    int m,v;
};
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n,m,t;
    cin>>n>>m>>t;
    vector<node>a(n+1);
    vector<vector<int>>dp(m+1,vector<int>(t+1));    
    for(int i=1;i<=n;i++)cin>>a[i].m>>a[i].v;
    for(int i=1;i<=n;i++)
    {
        for(int j=m;j>=a[i].m;j--)
        {
            for(int k=t;k>=a[i].v;k--)
            {
                dp[j][k]=max(dp[j][k],dp[j-a[i].m][k-a[i].v]+1);
            }
        }
    }
    cout<<dp[m][t]<<'\n';
    return 0;    
}

F - 石子合并

https://www.luogu.com.cn/problem/P1880

这一题本来是想用贪心算法的，但是贪心本质逻辑是错误的，应该用区间dp

#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;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n;
    cin>>n;
    vector<int>a(2*n+1);
    vector<vector<int>>f(2*n+1,vector<int>(2*n+1,inf/2)),g(2*n+1,vector<int>(2*n+1,-inf/2));
    vector<ll>prev(2*n+1);
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
        a[i+n]=a[i];
    }
    for(int i=1;i<=2*n;i++)
    {
        prev[i]+=prev[i-1]+a[i];
        f[i][i]=0;
        g[i][i]=0;
    }
    for(int len=2;len<=n;len++)
    {
        for(int i=1;i+len-1<=2*n;i++)
        {
            int j=i+len-1;
            for(int k=i;k<j;k++)
            {
                f[i][j]=min(1LL*f[i][j],f[i][k]+f[k+1][j]+prev[j]-prev[i-1]);
                g[i][j]=max(1LL*g[i][j],g[i][k]+g[k+1][j]+prev[j]-prev[i-1]);
            }
        }
    }
    int minn=inf,maxn=-inf;
    for(int i=1;i<=n;i++)
    {
        minn=min(minn,f[i][i+n-1]);
        maxn=max(maxn,g[i][i+n-1]);
    }
    cout<<minn<<'\n'<<maxn<<'\n';
    return 0;    
}

这个是洛谷上石子合并的弱化版，这个石子是呈线性分布的

https://www.luogu.com.cn/problem/P1775

#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;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n;
    cin>>n;
    vector<ll>prev(n+1);
    vector<int>a(n+1);
    vector<vector<int>>dp(n+1,vector<int>(n+1,inf/2));
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
        prev[i]=prev[i-1]+a[i];
        dp[i][i]=0;// 合并每个i本身没有花费，所以直接初始化为0
    }    
    for(int len=2;len<=n;len++)// 区间的大小，从2到n
    {
        for(int i=1;i+len-1<=n;i++)//区间起点
        {
            int j=i+len-1;// 区间终点
            for(int k=i;k<j;k++)// 切割位置
            {
                dp[i][j]=min(1LL*dp[i][j],dp[i][k]+dp[k+1][j]+prev[j]-prev[i-1]);
            }
        }
    }
    cout<<dp[1][n]<<'\n';// 合并从1到n这个区间的最小花费


    return 0;    
}

[USACO16OPEN] 248 G

https://www.luogu.com.cn/problem/P3146

区间dp

#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;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n;
    cin>>n;
    vector<int>a(n+1);
    int ret=-inf;
    for(int i=1;i<=n;i++){cin>>a[i];ret=max(ret,a[i]);}
    vector<vector<int>>dp(n+1,vector<int>(n+1));
    for(int i=1;i<=n;i++)dp[i][i]=a[i];  // dp[i][j]数组表示将从i到j完全合并所能生成的值，如果不能合并就是0
    for(int len=2;len<=n;len++)
    {
        for(int i=1;i+len-1<=n;i++)
        {   
            int j=i+len-1;
            for(int k=i;k<j;k++)
            {
                // 加这个dp[i][k]是防止dp[i][k]和dp[k+1][j]都是0而强行合并成1 
                if(dp[i][k]==dp[k+1][j]&&dp[i][k])dp[i][j]=max(dp[i][j],dp[i][k]+1);
                ret=max(ret,dp[i][j]);
            }
        }
    }
    cout<<ret<<'\n';
    return 0;    
}

H - 没有上司的舞会

https://www.luogu.com.cn/problem/P1352

树形DP,首先构建出整个树的结构，然后找出根节点，将每个节点分为选和不选两个状态（由dp数组第二维控制，0为不选，1为选），然后递归求解

#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;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n;
    cin>>n;
    vector<int>a(n+1),fa(n+1);
    for(int i=1;i<=n;i++)cin>>a[i];
    vector<vector<int>>adj;
    for(int i=1;i<n;i++)
    {
        int a,b;
        cin>>a>>b;
        adj[b].push_back(a);
        fa[a]=b;
    }    
    int root=0;
    for(int i=1;i<=n;i++)
    {
        if(fa[i]==0){root=i;break;}
    }
    vector<vector<int>>dp(n+1,vector<int>(2));
    auto dfs=[&](auto self,int u)->void{
        dp[u][1]+=a[u];
        for(auto v:adj[u])
        {
            self(self,v);
            dp[u][1]+=dp[v][0];
            dp[u][0]+=max(dp[v][0],dp[v][1]);
        }
    };
    dfs(dfs,root);
    cout<<max(dp[root][0],dp[root][1])<<"\n";
    return 0;    
}

最大子段和

https://www.luogu.com.cn/problem/P1115

这一个题就是常规的DP，不过贪心更容易想到

#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;    
}

乌龟棋

https://www.luogu.com.cn/problem/P1541

==本题由于规定每个数字最多有40个，限定了大小，可以开四维数组求解

#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 maxn=41;
int dp[maxn][maxn][maxn][maxn];
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>cnt(5);
    for(int i=1;i<=m;i++)
    {
        int x;
        cin>>x;
        cnt[x]++;
    }
    dp[0][0][0][0]=a[1];
    for(int i=0;i<=cnt[1];i++)
    {
        for(int j=0;j<=cnt[2];j++)
        {
            for(int k=0;k<=cnt[3];k++)
            {
                for(int d=0;d<=cnt[4];d++)
                {
                    int r=1+i*1+j*2+k*3+d*4;// 计算到达的位置
                    if(i)dp[i][j][k][d]=max(dp[i][j][k][d],dp[i-1][j][k][d]+a[r]);
                    if(j)dp[i][j][k][d]=max(dp[i][j][k][d],dp[i][j-1][k][d]+a[r]);
                    if(k)dp[i][j][k][d]=max(dp[i][j][k][d],dp[i][j][k-1][d]+a[r]);
                    if(d)dp[i][j][k][d]=max(dp[i][j][k][d],dp[i][j][k][d-1]+a[r]);
                }
            }
        }
    }
    cout<<dp[cnt[1]][cnt[2]][cnt[3]][cnt[4]]<<'\n';

    return 0;    
}
klb326327
关注
zzu_map_2019-3.png
01-13
郑州大学平面图郑州大学平面图郑州大学平面图郑州大学平面图郑州大学平面图郑州大学平面图郑州大学平面图郑州大学平面图
zzu操作系统实验1-23报告
01-24
《操作系统》实验3文件移动与查找 《操作系统》实验4文件查找、内容查看与域排序 《操作系统》实验5域排序与记录连接 《操作系统》实验6记录连接与剪切 《操作系统》实验7记录粘贴与分割 《操作系统》实验8目录属性...
zzu 2024寒假训练day1(A-I)
2301_79076926的博客
01-23 552
用数组的话,查找k和删除操作中查找x都是logn的操作,会超时,因此使用链表比较方便,用pos数组储存迭代器可弥补list不能随机访问的缺陷(复杂的题还是用静态链表吧).经典的栈问题 用num=num*10+s[i]求出操作数,再入栈,碰到运算符号,则取栈中的两个数运算,再将运算结果入栈.遇左端点入栈,遇右端点与栈顶元素结合并将差值插入小根堆,c插入大根堆,用小的区间消化的大的c。2.找出没一轮的怪物候选人(第一轮过后死的怪物的左右即为候选人,用set储存)1.数据的输入,链表的初始化连接。
zzu 2024寒假训练day2(A-D,F-I)
2301_79076926的博客
01-25 553
这个题关键要想到,前面的泥坑被覆盖后,板子可能已经覆盖了后面的泥坑,故用end记录板子覆盖的结尾,如果泥坑被全部覆盖,直接找下个泥坑,如果泥坑被覆盖一部分,把这个泥坑的起始点设为end即可,如果泥坑未被覆盖则不做处理,后面正常算即可。想要消耗体力最多,容易想到从平地跳到最高点,再跳到最低点,再跳到次高点,再跳到次低点...故从小到大排序,再用两个指针分别指向两端,轮流移动即可。比如[1,100000],[2,4],[4,5],最优是2,而这种思路的结果是1,所以光开始的早不行,结束时间不能太晚。
ZZU 2022 Train 4---复盘
ZZU_LGY
02-07 457
ZZU 2022 Train 4补题B - Paired Payment---dijkstra+dpD - Restore Permutation---树状数组+二分E - Erase and Extend (Easy Version)F - Erase and Extend (Hard Version)G - 0-1-TreeH - Special Segments of PermutationI - Constructing the Array 个人感觉这次题出的还是很好的，都是cf对应的C-E题，所以
zzu2024寒假训练day5(A-H)
2301_79076926的博客
02-16 687
本来还有一道i题,但本人比较菜,不会写,所以只有A到H。
300. 最长递增子序列-动态规划
小菜鸡
03-03 53
300. 最长递增子序列 给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。 子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。 示例 1： 输入：nums = [10,9,2,5,3,7,101,18] 输出：4 解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。 示例 2： 输入：nums = [0,1,0,3,2,3] 输出：4 示例 3： 输入：num
ZZU2024年迎新赛复盘----F题
Kaltist_1的博客
03-11 230
到达第n号格子的方案数，其实也就是到达第n-1号格子的方案数加上n-2号格子的方案数。（因为想到n号只能由n-1或n-2号格子到达）换言之，就是后者状态由前者所决定，经典的状态转移方程，经典的dp，题解如下。但是，再比赛时看见又是对大数据取模输出又感觉是dp下意识直接跳过，实际静下心想想这题根本不难甚至之前学过无数次，这就是比赛打得少，经验问题和心态问题（都怪前缀和那道题endl卡我好久其他题都看得浮光掠影的）总之不要被大数据吓到，特别是题目描述少的题都不会太复杂，以上。
入门-动态规划
君只见独不见的专栏
04-15 377
1. [分梨] 2. 最大公共子序列 3. [最大子段和] 4. [最大子阵和] 5. [母牛的故事] 6. [数塔] 7. [一只小蜜蜂] 8. [折线分割平面] 9. [献给杭电五十周年]
zzu 10467: 控制食欲 --01背包
几人憔悴几人泪
05-01 330
10467: 控制食欲 Time Limit: 1 Sec  Memory Limit: 128 MB Submit: 53  Solved: 15 [Submit][Status][Web Board] Description MM像她的诸多姊妹一样，爱吃零食但又爱美，为了控制体重我们将她置于一个及其严格的节食计划之中。她每天食物不能超过H 克(5 Inpu
剑指 Offer II 095. 最长公共子序列-动态规划
小菜鸡
03-01 133
动态规划
多媒体信号处理ECTE401-Tutorial-03-ZZU15-Solns.pdf
08-02
【多媒体信号处理ECTE401教程3-ZZU15解决方案】 本教程主要涵盖了多媒体信号处理中的核心概念，特别是语音信号的建模与分析。以下是教程中的几个关键知识点： 1. **源-滤波器模型（Source-Filter Model）**： ...
计算机系统基础课后题答案（部分）-zzu
11-13
计算机系统基础知识点 本资源摘要信息涵盖了计算机系统基础知识的多个方面，包括计算机系统概述、处理器、总线、存储器、输入/输出设备、计算机层次结构、摩尔定律、冯·诺伊曼计算机设计思想等。...
ZZU-CTF部分题目
03-24
赛题中的pwn和re题目，比较基础，可以拿来练手
【AGC005D】~K Perm Counting（计数抽象成图）
2301_77025310的博客
10-01 2256
注意到位置为id，权值为v ,不合法的情况，当且仅当 v = id+k或 v= id-k。dp(i,j,pd)表示考虑到第i号点， 连了j条边，是否有连接i 到 i-1号点。因此，我们把每一个位置和权值抽象成点 ，不合法的情况之间连一条边，可以构成二分图。由此可知，当选了n条边，就恰好n个位置不合法，限制条件是：连的边不能相邻，求出f(m) ，f(m)指代至少有m个位置不合法的方案数。由此总共有2n 个点 k 条链，链与链之间无边 互不干涉。把二分图展开成k条链，进行dp。简单的乘法原理罢了。
Javascript算法——双指针法移除元素、数组去重、比较含退格字符、有序数组平方
最新发布
警警的博客
10-17 287
暴力求解法（两层for循环）,length单词拼写错误❌二次嵌套for的length设置。return位置❌ ,核心基础。双指针法（一层for循环）
二叉树系列 10/11
2301_78191305的博客
10-11 430
在这些路径中，只有红色和绿色的路径是伪回文路径，因为红色路径 [2,3,3] 存在回文排列 [3,2,3] ，绿色路径 [2,1,1] 存在回文排列 [1,2,1]。总共有 3 条从根到叶子的路径：红色路径 [2,3,3] ，绿色路径 [2,1,1] 和路径 [2,3,1]。（如果 A 的任何子节点之一为 B，或者 A 的任何子节点是 B 的祖先，那么我们认为 A 是 B 的祖先）（一个节点的祖父节点是指该节点的父节点的父节点。」的，当它满足：路径经过的所有节点值的排列中，存在一个回文序列。
【算法】深入了解 CRC 校验码的计算过程
qq_20623849的博客
10-16 436
CRC（循环冗余校验，Cyclic Redundancy Check）是一种常见的错误检测方法，它通过生成冗余码来确保数据传输的可靠性。在这篇文章中，我们将探讨 CRC 码的基本原理，并详细介绍其计算过程。通过对数据进行 CRC 校验，我们可以在传输过程中检测到潜在的错误并采取适当的纠正措施。这个新的数据包在传输时，如果接收方再次计算 CRC 校验码并与附带的校验码进行比较，可以确定数据是否在传输过程中出现了错误。：将附加了零位的数据通过生成多项式进行二进制除法运算，得出的余数就是 CRC 校验码。
【LeetCode每日一题】——523.连续的子数组和
IronmanJay的博客
10-17 439
给你一个整数数组 nums 和一个整数 k ，如果 nums 有一个 好的子数组 返回 true ，否则返回 false： 一个 好的子数组 是： 长度 至少为 2 ，且 子数组元素总和为 k 的倍数。 注意： 子数组 是数组中 连续 的部分。 如果存在一个整数 n ，令整数 x 符合 x = n * k ，则称 x 是 k 的一个倍数。0 始终 视为 k 的一个倍数。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值