2024牛客寒假算法基础集训营4【难题详解】

原创 已于 2024-02-21 02:10:51 修改 · 506 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法

于 2024-02-21 01:27:30 首次发布
文章讲述了如何使用动态规划方法解决一个涉及区间最大值的问题，包括状态转移方程的更新和空间优化策略，如使用一维数组、二维数组以及滚动数组来降低空间复杂度。最后提到与K.方块掉落问题的关联，可能是题目来源或者应用实例。

F. 来点每日一题

DP

由题容易想到的：

dp[i]表示 1-i 中求得的最大值， 所以最后ans为 dp[n]

状态转移与之前dp不一样的是，需要二维枚举，并且此题n的范围小，可以二维枚举：

dp[j]=max(dp[i-1]+cal(i,j)，dp[j]);

cal(i,j)表示选 i~j 这个区间的最大值,如何计算?        还是DP

$\left(\left(b_1-b_2\right)\times b_3-b_4\right)\times b_5-b_6$

由于式子中有乘法，所以既要维护[i,j]区间的最大值，也要维护最小值

mx[i][j][1]=表示选了式子中的第一个数b1

状态转移：按选或不选第j个数划分

mx[i][j][1]=max(a[j],mx[i][j-1][1]);

mx[i][j][2]=max(mx[i][j-1][1]-a[j],mx[i][j-1][2]);

mx[i][j][3]=max(mx[i][j-1][2]*a[j],mx[i][j-1][3]);

mx[i][j][4]=max(mx[i][j-1][3]-a[j],mx[i][j-1][4]);

mx[i][j][5]=max(mx[i][j-1][4]*a[j],mx[i][j-1][5]);

mx[i][j][6]=max(mx[i][j-1][5]-a[j],mx[i][j-1][6]);

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define all(x) x.begin(),x.end()
#define no cout<<"No"<<endl
#define yes cout<<"Yes"<<endl
#define endl '\n'
// #define x first
// #define y second
typedef pair<int,int> PII;
const int N=200010;
const int mod=998244353;
const int INF=0x3f3f3f3f3f3f3f3f;
void solve(){
    int n;cin>>n;
    vector<int>a(n+1);
    for(int i=1;i<=n;i++){
        cin>>a[i];
    }
    int mx[n+1][n+1][7]={};int mn[n+1][n+1][7]={};
    for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)for(int k=1;k<=6;k++)
        mx[i][j][k]=-INF,mn[i][j][k]=INF;

    for(int i=1;i<=n;i++){
        mx[i][i][1]=mn[i][i][1]=a[i];
        for(int j=i+1;j<=n;j++){
            for(int k=1;k<=6;++k)mx[i][j][k]=mx[i][j-1][k],mn[i][j][k]=mn[i][j-1][k];

            mx[i][j][1]=max(a[j],mx[i][j][1]);
            mn[i][j][1]=min(a[j],mn[i][j][1]);
            
            if(mx[i][j-1][1]!=-INF)mx[i][j][2]=max(mx[i][j-1][1]-a[j],mx[i][j][2]);
            if(mn[i][j-1][1]!=INF)mn[i][j][2]=min(mn[i][j-1][1]-a[j],mn[i][j][2]);

            if(mx[i][j-1][2]!=-INF)mx[i][j][3]=max(mx[i][j-1][2]*a[j],mx[i][j][3]);
            if(mn[i][j-1][2]!=INF)mx[i][j][3]=max(mn[i][j-1][2]*a[j],mx[i][j][3]);
            if(mx[i][j-1][2]!=-INF)mn[i][j][3]=min(mx[i][j-1][2]*a[j],mn[i][j][3]);
            if(mn[i][j-1][2]!=INF)mn[i][j][3]=min(mn[i][j-1][2]*a[j],mn[i][j][3]);
            
            if(mx[i][j-1][3]!=-INF)mx[i][j][4]=max(mx[i][j-1][3]-a[j],mx[i][j][4]);
            if(mn[i][j-1][3]!=INF)mn[i][j][4]=min(mn[i][j-1][3]-a[j],mn[i][j][4]);

            if(mx[i][j-1][4]!=-INF)mx[i][j][5]=max(mx[i][j-1][4]*a[j],mx[i][j][5]);
            if(mn[i][j-1][4]!=INF)mx[i][j][5]=max(mn[i][j-1][4]*a[j],mx[i][j][5]);
            if(mx[i][j-1][4]!=-INF)mn[i][j][5]=min(mx[i][j-1][4]*a[j],mn[i][j][5]);
            if(mn[i][j-1][4]!=INF)mn[i][j][5]=min(mn[i][j-1][4]*a[j],mn[i][j][5]);
            
            if(mx[i][j-1][5]!=-INF)mx[i][j][6]=max(mx[i][j-1][5]-a[j],mx[i][j][6]);
            if(mn[i][j-1][5]!=INF)mn[i][j][6]=min(mn[i][j-1][5]-a[j],mn[i][j][6]);
        
        }
    }

    vector<int>dp(n+1);
    for(int i=1;i<=n;i++){
        dp[i]=max(dp[i-1],dp[i]);
        for(int j=i+1;j<=n;j++){
            dp[j]=max(dp[i-1]+mx[i][j][6],dp[j]);
        }
    }
    cout<<dp[n]<<endl;
}
signed main(){
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    int _=1;
    while(_--)solve();
    return 0;
}

注意：若不写for(int k=1;k<=6;++k)mx[i][j][k]=mx[i][j-1][k],mn[i][j][k]=mn[i][j-1][k];

只写if(mx[i][j-1][2]!=-INF)mx[i][j][3]=max(mx[i][j-1][2]*a[j],mx[i][j-1][3]);是不行的

因为if判断为false的话， mx[i][j-1][3] 这个状态就不会被考虑。

空间优化

mx[j][7]表示，在当前遍历的 i~j 中所满足的最大值

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define all(x) x.begin(),x.end()
#define no cout<<"No"<<endl
#define yes cout<<"Yes"<<endl
#define endl '\n'
// #define x first
// #define y second
typedef pair<int,int> PII;
const int N=200010;
const int mod=998244353;
const int INF=0x3f3f3f3f3f3f3f3f;
void solve(){
    int n;cin>>n;
    vector<int>a(n+1);
    for(int i=1;i<=n;i++){
        cin>>a[i];
    }
    
    vector<int>dp(n+1);
    for(int i=1;i<=n;i++){

        int mx[n+1][7]={};int mn[n+1][7]={};
        for(int j=1;j<=n;j++)for(int k=1;k<=6;k++)
            mx[j][k]=-INF,mn[j][k]=INF;
        mx[i][1]=a[i],mn[i][1]=a[i];

        for(int j=i+1;j<=n;j++){
            for(int k=1;k<=6;++k)mx[j][k]=mx[j-1][k],mn[j][k]=mn[j-1][k];

            mx[j][1]=max(a[j],mx[j][1]);
            mn[j][1]=min(a[j],mn[j][1]);

            if(mx[j-1][1]!=-INF)mx[j][2]=max(mx[j-1][1]-a[j],mx[j][2]);
            if(mn[j-1][1]!=INF)mn[j][2]=min(mn[j-1][1]-a[j],mn[j][2]);

            if(mx[j-1][2]!=-INF)mx[j][3]=max(mx[j-1][2]*a[j],mx[j][3]);
            if(mn[j-1][2]!=INF)mx[j][3]=max(mn[j-1][2]*a[j],mx[j][3]);
            if(mx[j-1][2]!=-INF)mn[j][3]=min(mx[j-1][2]*a[j],mn[j][3]);
            if(mn[j-1][2]!=INF)mn[j][3]=min(mn[j-1][2]*a[j],mn[j][3]);
            
            if(mx[j-1][3]!=-INF)mx[j][4]=max(mx[j-1][3]-a[j],mx[j][4]);
            if(mn[j-1][3]!=INF)mn[j][4]=min(mn[j-1][3]-a[j],mn[j][4]);

            if(mx[j-1][4]!=-INF)mx[j][5]=max(mx[j-1][4]*a[j],mx[j][5]);
            if(mn[j-1][4]!=INF)mx[j][5]=max(mn[j-1][4]*a[j],mx[j][5]);
            if(mx[j-1][4]!=-INF)mn[j][5]=min(mx[j-1][4]*a[j],mn[j][5]);
            if(mn[j-1][4]!=INF)mn[j][5]=min(mn[j-1][4]*a[j],mn[j][5]);
            
            if(mx[j-1][5]!=-INF)mx[j][6]=max(mx[j-1][5]-a[j],mx[j][6]);
            if(mn[j-1][5]!=INF)mn[j][6]=min(mn[j-1][5]-a[j],mn[j][6]);
            
            dp[j]=max(dp[i-1]+mx[j][6],dp[j]);
        }
    }

    cout<<dp[n]<<endl;
}
signed main(){
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    int _=1;
    while(_--)solve();
    return 0;
}

甚至还能用滚动数组继续优化

mx[7]表示，在当前遍历的 i~j 中所满足的最大值

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define all(x) x.begin(),x.end()
#define no cout<<"No"<<endl
#define yes cout<<"Yes"<<endl
#define endl '\n'
// #define x first
// #define y second
typedef pair<int,int> PII;
const int N=200010;
const int mod=998244353;
const int INF=0x3f3f3f3f3f3f3f3f;
void solve(){
    int n;cin>>n;
    vector<int>a(n+1);
    for(int i=1;i<=n;i++){
        cin>>a[i];
    }
    
    vector<int>dp(n+1);
    for(int i=1;i<=n;i++){

        vector<int>mx1(7,-INF),mn1(7,INF);
        mx1[1]=mn1[1]=a[i];

        for(int j=i+1;j<=n;j++){
            vector<int>mx=mx1,mn=mn1;

            mx[1]=max(a[j],mx[1]);
            mn[1]=min(a[j],mn[1]);

            if(mx1[1]!=-INF)mx[2]=max(mx1[1]-a[j],mx[2]);
            if(mn1[1]!=INF)mn[2]=min(mn1[1]-a[j],mn[2]);

            if(mx1[2]!=-INF)mx[3]=max(mx1[2]*a[j],mx[3]);
            if(mn1[2]!=INF)mx[3]=max(mn1[2]*a[j],mx[3]);
            if(mx1[2]!=-INF)mn[3]=min(mx1[2]*a[j],mn[3]);
            if(mn1[2]!=INF)mn[3]=min(mn1[2]*a[j],mn[3]);
            
            if(mx1[3]!=-INF)mx[4]=max(mx1[3]-a[j],mx[4]);
            if(mn1[3]!=INF)mn[4]=min(mn1[3]-a[j],mn[4]);

            if(mx1[4]!=-INF)mx[5]=max(mx1[4]*a[j],mx[5]);
            if(mn1[4]!=INF)mx[5]=max(mn1[4]*a[j],mx[5]);
            if(mx1[4]!=-INF)mn[5]=min(mx1[4]*a[j],mn[5]);
            if(mn1[4]!=INF)mn[5]=min(mn1[4]*a[j],mn[5]);
            
            if(mx1[5]!=-INF)mx[6]=max(mx1[5]-a[j],mx[6]);
            if(mn1[5]!=INF)mn[6]=min(mn1[5]-a[j],mn[6]);
            
            dp[j]=max(dp[i-1]+mx[6],dp[j]);
            
            mx1=mx;
            mn1=mn;
        }

    }

    cout<<dp[n]<<endl;
}
signed main(){
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    int _=1;
    while(_--)solve();
    return 0;
}

K. 方块掉落

Perfect_Life_
关注
2024牛客寒假算法基础集训营2【难题详解】
Perfect_Life_的博客
02-14 428
题意：将物品移动n-k步的最小价值，移动ai步需要花费bi (若>=n则%n)此题不能用单调队列优化，因为取模的关系，导致状态转移没有单调性。
2024牛客寒假算法基础集训营1【难题详解】
Perfect_Life_的博客
02-03 218
dp[j]表示：满足m的二进制表示下第j位为1，且背包的体积=m-(1
2024牛客寒假算法基础集训营3【难题详解】
Perfect_Life_的博客
02-15 276
【代码】2024牛客寒假算法基础集训营3【难题详解】
2023牛客寒假算法基础集训营6(题解及经验总结)
qq_73635134的博客
02-14 331
2023牛客寒假算法基础集训营6 A 阿宁的签到题 B 阿宁的倍数 C 阿宁的大背包 D 阿宁的毒瘤题 E 阿宁的生成树 F 阿宁的二进制 G 阿宁的整数配对 H 阿宁讨伐虚空 I 阿宁前往沙城
牛客寒假算法基础集训营4 C. Applese走迷宫(bfs)
Charles_Zaqdt的博客
01-30 342
  题目链接：https://ac.nowcoder.com/acm/contest/330/C        其实就是一个简单的bfs，只不过多了一个标记，结构体中多开一个变量用来记录当前的状态，然后在搜索的时候单独判断一下遇到'@'的情况就好了(将切换状态和不变都扔入队列中)，剩下的就是一个简单的bfs... AC代码： #include &lt;bits/stdc++.h&gt; ...
22.11.9打卡 2022牛客寒假算法基础集训营5I题详解
Tanya_xiaomai的博客
11-09 511
虽然这题存在一个入睡时间k, 但和原做法也差别不了太多, 首先看t数组, 做差分, 得到叉同学发说说的间隔时间, 由题意得, 入睡需要k时间, 那么间隔时间
2020牛客寒假算法基础集训营2 数三角 思维几何题 详解
蜡笔小新冲鸭！！！
07-21 188
题目链接：https://ac.nowcoder.com/acm/contest/3003/D 题目描述： 思路： 1.枚举三个点（不要计算出每条边，再枚举三条边，因为复杂度过大），判断其三边长是否符合aa+bb<c*c; 2.判断三遍是否共线（重点，易忽略）。 代码： #include<bits/stdc++.h> using namespace std; #define ll long long #define ull unsigned long long const int ma
2022牛客寒假算法基础集训营1
m0_51508220的博客
02-01 2811
记录牛客训练营补题感悟。
2020牛客寒假算法基础集训营2 G判正误详解（思路题）
蜡笔小新冲鸭！！！
07-21 168
题目链接： https://ac.nowcoder.com/acm/contest/3003/G 出题人思路： 我的看法：开始时完全没明白是啥意思，直到看了网上的其他题解才有点思路。关键句是：多选择一些模数以提高正确率。。。 代码： #include<bits/stdc++.h> using namespace std; #define ll long long #define ull unsigned long long const int maxn=2e5+5; const int m
2020牛客寒假算法基础集训营3——G.牛牛的Link Power II【线段树】（画图详解）
NIRVANA REBIRTH
02-09 660
题目传送门 题目描述 牛牛有一颗大小为 nnn 的神奇 Link−CutLink-CutLink−Cut 数组，数组上的每一个节点都有两种状态，一种为 linklinklink 状态，另一种为cut状态。数组上任意一对处于link状态的无序点对（即(u,v)和(v,u)被认为是同一对）会产生dis(u,v)的link能量，dis(u,v)为数组上u到v的距离。 我们定义整个数组的Link能量为所...
动态规划DP【持续更新】
NIRVANA REBIRTH
11-24 734
动态规划   动态规划（英语：Dynamic programming，简称DP）是一种在数学、管理科学、计算机科学、经济学和生物信息学中使用的，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。   动态规划常常适用于有重叠子问题和最优子结构性质的问题，动态规划方法所耗时间往往远少于朴素解法。   动态规划背后的基本思想非常简单。大致上，若要解一个给定问题，我们需要解其不同部分（即子问题...
PageRank 算法：互联网的“人气投票”
core815的专栏
12-26 961
PageRank 算法：互联网的“人气投票”
hot100-51搜索二维矩阵
youngee11的博客
12-25 297
对于任意一维索引mid，转换为二维坐标，行号：row=mid/n，列号：col=mid%n。2、这个题目的特性是，每行的第一个元素 > 上一行的最后一个怨怒是，说明所有行是严格递增拼接的，使用上面的解法时间复杂度是O(m+n)，如果使用二分查找时间复杂度是O(log(mn))。m×n的矩阵，每行中的整数从左到右递增排列，每行第一个整数大于前一行的最后一个整数。给定矩阵和target，如果target在矩阵中，返回true，否则返回false。// 取余 → 得到“在该行中的偏移”→ 向下走（排除这一行）；
TDCA 算法在 SSVEP-BCI 中的时间戳技术要求与工程实现
m0_63827302的博客
12-26 624
在基于稳态视觉诱发电位（Steady-State Visual Evoked Potential, SSVEP）的脑机接口（Brain-Computer Interface, BCI）系统中，任务驱动成分分析（Task-Driven Component Analysis, TDCA）作为核心的有监督时空特征学习算法，其性能高度依赖于脑电信号（Electroencephalogram, EEG）与视觉刺激事件的时序一致性 —— 而时间戳正是保障这一一致性的关键技术支撑。
【AI称重算法落地指南】实施步骤、多算法方案与避坑手册
昔时扬尘处
12-27 53
AI称重算法的落地核心是“硬件精准采样+数据高质量标注+轻量化模型适配”，结合STM32G4的算力优势与NanoEdge AI Studio的低代码开发能力，可快速实现100克级精度的称重方案。在算法选型上，静态场景优先DNN（资源占用低、精度高），动态/噪声场景优先CNN（抗干扰强），时序依赖场景优先RNN（快速响应）。实际应用中需重点解决数据分布、噪声干扰、硬件适配三大核心问题，通过样本扩充、软硬件协同优化、现场自学习等手段，确保方案的可靠性与量产适配性。
【计算几何 化环为链】P14165 [ICPC 2022 Nanjing R] 清空水箱|普及+
最新发布
闻缺陷则喜何志丹
12-28 931
本文研究了ICPC 2022南京站竞赛题目"清空水箱"的解法。该问题要求在多边形水箱上安装最少数量的出水阀门，使得打开所有阀门后水箱中的水能完全流出。通过计算几何分析，发现只需在满足特定条件的顶点处安装阀门即可。关键点在于：1) 处理相邻顶点共线的情况；2) 使用化环为链的方法简化多边形处理；3) 通过叉积判断顶点是否需要阀门。最终解法时间复杂度为O(n)，适用于顶点数n≤2000的情况。样例测试验证了算法的正确性，如样例1需2个阀门，样例2仅需1个。
Q-learning 算法 —— 无模型（model-free）强化学习
一杯水果茶！足矣~
12-25 1414
从已知模型到 Model-free 的强化学习转变：Q-Learning 算法，通过详细示例来讲解，理解 Q-table 的更新和贪婪策略
day124—二分查找—最小化数组中的最大值（LeetCode-2439）
the_dry的博客
12-24 364
摘要：给定一个非负整数数组，通过操作（将元素i减1并使其左侧元素加1）调整数组，目标是使调整后的数组最大值最小化。解决方案采用二分查找：猜测最大值并用贪心算法验证。从右向左遍历数组，将超出限制的值向左传递，最后检查首元素是否满足限制。时间复杂度为O(nlogM)，其中M是数组最大值。该方法利用单调性和贪心策略高效找到最优解。
可视化图解算法75：最长上升子序列(最长递增子序列)
weixin_42117918的博客
12-25 690
对于LeetCode数据结构与算法，我们总结了一套【可视化+图解】方法，依据此方法来解决相关问题，算法变得易于理解，写出来的代码可读性高也不容易出错。
2020牛客寒假算法基础集训营欧几里得
01-03
### 关于2020年牛客寒假算法基础集训营中的欧几里得算法 在2020年的牛客寒假算法基础集训营中，确实存在涉及欧几里得算法的相关题目。具体来说，在第四场竞赛的第一题即为“A. 欧几里得”，该题目的核心在于利用扩展欧几里得定理来解决问题[^5]。 #### 扩展欧几里得算法简介 扩展欧几里得算法主要用于求解形如 ax + by = gcd(a, b) 的线性不定方程的一组特解(x,y)，其中gcd表示最大公约数。此方法不仅能够计算两个整数的最大公因数，还能找到满足上述条件的具体系数x和y。 对于给定的数据范围较小的情况可以直接通过递归来实现；而对于较大数据则需考虑效率优化问题。下面给出了一段基于C++语言编写的用于解决此类问题的模板代码： ```cpp #include<bits/stdc++.h> #define int long long using namespace std; // 定义全局变量存储结果 int x, y; void ex_gcd(int a, int b){ if(b == 0){ x = 1; y = 0; return ; } ex_gcd(b, a % b); int tmp = x; x = y; y = tmp - (a / b) * y; } ``` 这段程序实现了经典的扩展欧几里得算法逻辑，并且可以作为处理类似问题的基础工具函数调用。 #### 实际应用案例分析 回到原题本身，“A. 欧几里得”的解答思路就是先预处理斐波那契数列前若干项数值存入数组`a[]`内以便快速查询，之后针对每一次询问直接输出对应位置处两相邻元素之和即可得出最终答案。这实际上巧妙运用到了广为人知的裴蜀定理——任意一对互质正整数都可由它们自身的倍数组合而成，而这里正是借助了这一性质简化了解决方案的设计过程。
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值