P5069 [Ynoi2015] 纵使日薄西山

已于 2024-04-11 07:30:35 修改
阅读量394 收藏 6
点赞数 3
分类专栏： ynoi_ds题 文章标签： 算法
于 2024-04-11 07:30:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lanthamum/article/details/137605036
版权

纵使日薄西山,我也想保护你..

先不考虑单点修改

手玩一下样例

可以发现你一直操作一个数的结果是和答案一样的

可以大致证明一下

x y z

如果选择y操作，那么x,z必然不能操作，因为x,z会和y一直减少，只有y做出了贡献,所以我们的答案应该是选的数之和

因此应该只有2种操作方法

操作1 ，3，5，7...

操作2，4，6，8...

也就是维护一个奇偶性相同的单增或者单减序列

挺抽象的，这种做法待补

我们可以用线段树来维护需要被操作的值（合并很妙）

我们先思考一下，我们需要维护哪些值，左端点有没有被操作的，右端点有没有被操作的，以及如果左端点需要被操作的贡献是多少，右端点需要被操作的贡献是多少，如果两端都被操作的贡献是多少，因此我们维护四颗线段树，seg[N<<2][4]。

0是左右两端都没有被操作

1是左端点需要被操作

2是右端点需要被操作

3是左右端点都要被操作

struct node{
    ll lf,rf,val;
}seg[N<<2][4];// 1l,2r,3all,0no

感觉也很抽象我们可以举一个例子(标记X是需要被操作的,O是在其他操作范围区间的）

134554
0XXXX
1OXOX
2XOXO
3OXOOXO

假设 1 3 4 5 5 4合并

134554
0XXX
1OXXX
2XXO
3OXXO

可以发现[0]的左边是从2转移过来的，右边从[0]转移过来的，判断依据是5>4

因此就是a[mid]与a[mid+1]的大小关系

接下来，我们就仔细分析每种情况的转移方案

1. if()在两端都不用管的情况下,如果左子树的右端点有标记，右子树的左端点有标记

（i）左边大于等于右边

那选择左边直接转移，右边转移左边有端点的那种情况，答案求和是左边（不管）+右边（左边要管）

（ii）右边大于左边

那选择右边直接转移，左边转移右边有端点的那种情况，答案求和是左边（右边要管）+右边（不管）

if(seg[tl(id)][0].rf && seg[tr(id)][0].lf){//左，右端点都存在
        if(a[mid]>=a[mid+1]){//左边大
            seg[id][0].lf=seg[tl(id)][0].lf;//选左边
            seg[id][0].rf=seg[tr(id)][1].rf;//转移如果左边要管的右边的rf
            seg[id][0].val=seg[tl(id)][0].val+seg[tr(id)][1].val;//左边（都要管）+右边（管左边）
        }else{//右边大
            seg[id][0].lf=seg[tl(id)][2].lf;//转移如果右边要管的左边的lf
            seg[id][0].rf=seg[tr(id)][0].rf;//选右边
            seg[id][0].val=seg[tl(id)][2].val+seg[tr(id)][0].val;//左边（管右边）+右边（都要管）
        }

else（）直接转移左右两边，答案也直接加

else{//直接拼
            seg[id][0].lf=seg[tl(id)][0].lf;
            seg[id][0].rf=seg[tr(id)][0].rf;
            seg[id][0].val=seg[tl(id)][0].val+seg[tr(id)][0].val;
    }

2.if()在要管左边的左子树有右端点标记以及不管的右子树有左端点

因为存在要管左边的，所以不用转移左边，考虑右边的转移即可

（i）左边大于等于右边

转移需要管左边的右边，答案求和是左边（管左边）+右边（管左边）

（ii）右边大于左边

直接转移，答案求和是左边（管两边）+右边（不管）

if(seg[tl(id)][1].rf && seg[tr(id)][0].lf){//左，右端点存在
        if(a[mid]>=a[mid+1]){
            seg[id][1].rf=seg[tr(id)][1].rf;
            seg[id][1].val=seg[tl(id)][1].val+seg[tr(id)][1].val;
        }else{
            seg[id][1].rf=seg[tr(id)][0].rf;
            seg[id][1].val=seg[tl(id)][3].val+seg[tr(id)][0].val;
        }

else() 直接转移

else{
        seg[id][1].rf=seg[tr(id)][0].rf;
        seg[id][1].val=seg[tl(id)][1].val+seg[tr(id)][0].val;
    }

3.if()不管的左子树有右端点以及管右边的右子树有左端点

同理考虑左端点的转移

（i）左边大于等于右边

转移需要不管的左边，答案求和是左边（不管）+右边（管两边）

（ii）右边大于左边

直接转移，答案求和是左边（管右边）+右边（管右边）

if(seg[tl(id)][0].rf && seg[tr(id)][2].lf){
        if(a[mid]>=a[mid+1]){
            seg[id][2].lf=seg[tl(id)][0].lf;
            seg[id][2].val=seg[tl(id)][0].val+seg[tr(id)][3].val;
        }else{
            seg[id][2].lf=seg[tl(id)][2].lf;
            seg[id][2].val=seg[tl(id)][2].val+seg[tr(id)][2].val;
        }

else()直接转移

if(seg[tl(id)][0].rf && seg[tr(id)][2].lf){
        if(a[mid]>=a[mid+1]){
            seg[id][2].lf=seg[tl(id)][0].lf;
            seg[id][2].val=seg[tl(id)][0].val+seg[tr(id)][3].val;
        }else{
            seg[id][2].lf=seg[tl(id)][2].lf;
            seg[id][2].val=seg[tl(id)][2].val+seg[tr(id)][2].val;
        }

4.if() 要管左边的左子树有右端点标记，要管右边的右子树有左端点标记

不用考虑左右端点转移

（i）左边大于等于右边

答案求和是左边（管左边）+右边（管两边）

（ii）右边大于左边

答案求和是左边（管两边）+右边（管右边）

if(seg[tl(id)][1].rf && seg[tr(id)][2].lf){
        if(a[mid]>=a[mid+1]){
            seg[id][3].val=seg[tl(id)][1].val+seg[tr(id)][3].val;
        }else{
            seg[id][3].val=seg[tl(id)][3].val+seg[tr(id)][2].val;
        }

else()直接转移

 seg[id][3].val=seg[tl(id)][1].val+seg[tr(id)][2].val;

讨论结束

可以发现只有中间存在重叠的情况才需要讨论左右端点的标记转移，其他情况直接转移即可

文字描述很拉垮，可以直接看码.

完整代码

#include<iostream>
#include<cmath>
#include<algorithm>
#include<bitset>
#include<cstring>
#include<vector>
#define INF (1ll<<30)
using namespace std;
typedef long long ll;
const int N=1e5+9;
namespace Lan {
    inline string sread() {
        string s=" ";char e=getchar();
        while(e==' '||e=='\n')e=getchar();
        while(e!=' '&&e!='\n')s+=e,e=getchar();
        return s;
    }
    inline void swrite(string s){
        for(char e:s)putchar(e);
        printf("\n");
    }
    inline ll read() {
        ll x=0,y=1;char c=getchar();
        while(!isdigit(c)){if(c=='-')y=-1;c=getchar();}
        while(isdigit(c)){x=(x<<3)+(x<<1)+(c^48);c=getchar();}
        return x*=y;
    }
    inline void write(ll x) {
        if(x<0){x=-x,putchar('-');}ll sta[35],top=0;
        do sta[top++]=x%10,x/=10;while(x);
        while(top)putchar(sta[--top]+'0');
    }
}using namespace Lan;
int a[N];
struct node{
    ll lf,rf,val;
}seg[N<<2][4];// 1l,2r,3all,0no
//  1 3 4 
//1 X   X
//2 X   X
//3 X   X   
//0 X   X
//  5 5 4
//1     X
//2 X
//3    
//0 X   X
ll tl(ll x){return x<<1;}
ll tr(ll x){return x<<1|1;}
void pushup(int id,int l,int r){
    int mid=(l+r)>>1;
    if(seg[tl(id)][0].rf && seg[tr(id)][0].lf){//左，右端点都存在
        if(a[mid]>=a[mid+1]){//左边大
            seg[id][0].lf=seg[tl(id)][0].lf;//选左边
            seg[id][0].rf=seg[tr(id)][1].rf;//转移如果左边要管的右边的rf
            seg[id][0].val=seg[tl(id)][0].val+seg[tr(id)][1].val;//左边（都要管）+右边（管左边）
        }else{//右边大
            seg[id][0].lf=seg[tl(id)][2].lf;//转移如果右边要管的左边的lf
            seg[id][0].rf=seg[tr(id)][0].rf;//选右边
            seg[id][0].val=seg[tl(id)][2].val+seg[tr(id)][0].val;//左边（管右边）+右边（都要管）
        }
    }else{//直接拼
            seg[id][0].lf=seg[tl(id)][0].lf;
            seg[id][0].rf=seg[tr(id)][0].rf;
            seg[id][0].val=seg[tl(id)][0].val+seg[tr(id)][0].val;
    }
    if(seg[tl(id)][1].rf && seg[tr(id)][0].lf){//左，右端点存在
        if(a[mid]>=a[mid+1]){
            seg[id][1].rf=seg[tr(id)][1].rf;
            seg[id][1].val=seg[tl(id)][1].val+seg[tr(id)][1].val;
        }else{
            seg[id][1].rf=seg[tr(id)][0].rf;
            seg[id][1].val=seg[tl(id)][3].val+seg[tr(id)][0].val;
        }
    }else{
        seg[id][1].rf=seg[tr(id)][0].rf;
        seg[id][1].val=seg[tl(id)][1].val+seg[tr(id)][0].val;
    }
    if(seg[tl(id)][0].rf && seg[tr(id)][2].lf){
        if(a[mid]>=a[mid+1]){
            seg[id][2].lf=seg[tl(id)][0].lf;
            seg[id][2].val=seg[tl(id)][0].val+seg[tr(id)][3].val;
        }else{
            seg[id][2].lf=seg[tl(id)][2].lf;
            seg[id][2].val=seg[tl(id)][2].val+seg[tr(id)][2].val;
        }
    }else{
        seg[id][2].lf=seg[tl(id)][0].lf;
        seg[id][2].val=seg[tl(id)][0].val+seg[tr(id)][2].val;
    }
    if(seg[tl(id)][1].rf && seg[tr(id)][2].lf){
        if(a[mid]>=a[mid+1]){
            seg[id][3].val=seg[tl(id)][1].val+seg[tr(id)][3].val;
        }else{
            seg[id][3].val=seg[tl(id)][3].val+seg[tr(id)][2].val;
        }
    }else{
        seg[id][3].val=seg[tl(id)][1].val+seg[tr(id)][2].val;
    }
}
void build(int id,int l,int r){
    if(l==r){
        seg[id][0].val=a[l];
        seg[id][0].lf=1;
        seg[id][0].rf=1;
    }else{
        int mid=(l+r)>>1;
        build(tl(id),l,mid);
        build(tr(id),mid+1,r);
        pushup(id,l,r);
    }
}
void update(int id,int l,int r,int pos,int val){
    if(l==r){
        seg[id][0].val=val;
    }else{
        int mid=(l+r)>>1;
        if(mid>=pos){
            update(tl(id),l,mid,pos,val);
        }else{
            update(tr(id),mid+1,r,pos,val);
        }
        pushup(id,l,r);
    }
}
int main(){
    // ios::sync_with_stdio(false);
    // cin.tie(0),cout.tie(0);
    int n;
    n=read();
    for(int i=1;i<=n;i++){
        a[i]=read();
    }
    build(1,1,n);
    int q;
    q=read();
    while(q--){
        int x,y;
        x=read(),y=read();
        a[x]=y;
        update(1,1,n,x,y);
        cout<<seg[1][0].val<<'\n';
    }
    return 0;
}

再次总结，ynoi题的真好，又学了一下如何维护多个量，lxl orz

Lanthanmum
关注
专栏目录
[Ynoi2015] 纵使日薄西山
dingxingdi的博客
05-19 386
按照题目来模拟，假设\(a_x\)为最大的，那么任意时刻不可能选中\(a_{x-1}\)或者\(a_{x+1}\)来操作的 然后就可以发现，我们选出的数一定是不相邻的，也就是说，我们每次在还可以选择的数中找出最大的数(满足此条件下下标最小)，并且把相邻的两个数标记为不可选择，一直重复这个过程直到为\(0\)；显然这个过程与操作顺序是无关的，只与我们选择出的数有关，答案就是我们选择出的数的和 像这...
Luogu P5069 [Ynoi2015] 纵使日薄西山
curry的博客
03-05 170
set维护极值点.
【树状数组】【P5069】[Ynoi2015]纵使日薄西山
weixin_34178244的博客
06-30 261
Description 给定一个长度为 \(n\) 的非负整数序列 \(\{a_n\}\)，\(q\) 次操作，每次要么单点修改序列某个值，要么查询整个序列需要操作多少次才能变成全 \(0\)。 一次操作是指：找到序列的最大值的位置，如果有多个最大值则取最左边的，然后将这个数和这个位置左右紧挨着的数都 \(-1\)，如果减到 \(0\) 则不减。 Limitation \(1~\leq~n,~q~...
洛谷P5069 [Ynoi2015]纵使日薄西山（树状数组，set）
a83229442的博客
03-08 198
洛谷题目传送门 一血祭 向dllxl致敬！ 算是YNOI中比较清新的吧，毕竟代码只有1.25k。 首先我们对着题意模拟，寻找一些思路。 每次选了一个最大的数后，它和它周围两个数都要减一。这样无论如何，我们都选不到旁边那两个数，只有第一次选的那个数会对答案产生它的大小的贡献。 于是就可以写出一个\(O(nm\log n)\)的暴力用来对拍了 #include<bits/stdc++....
[Ynoi2015]纵使日薄西山
03-26 568
题目大意： 给定一个序列，每次单点修改，然后进行询问。 定义一次操作为，选择一个位置$x$，将这个位置的数和左边、右边两个位置的数（不存在则忽略）各减去1，然后和0取max。 对序列中最大的位置进行一次操作（相同则取最前面的），不断重复，直到所有位置为0为止。 问执行了多少次操作。 询问互相独立（即下一次询问的序列并不是全0）。 解题思路： 在太阳西斜的这个世界里，置身天上...
P5072 [Ynoi2015] 盼君勿忘
SSL_WCR
06-07 387
题目 题目 思路 在太阳西斜的这个世界里，置身天上之森。 等这场战争结束之后，不归之人与望眼欲穿的众人， 人人本着正义之名， 长存不灭的过去、逐渐消逝的未来。 我回来了，纵使日薄西山，即便看不到未来，此时此刻的光辉，盼君勿忘。 ————世界上最幸福的女孩 显然子序列长度为len，则x的贡献为x的数量∗(2len−2len−x出现次数)x的数量*(2^{len}-2^{len-x出现次数})x的数量∗(2len−2len−x出现次数) 本题就是简单分块莫队，难点有2： 光速幂求2n TLE的威胁——没事
洛谷P5071 [YNOI2015]此时此刻的光辉 莫队+玄学优化+卡常QWQ
The_OIer的博客
08-10 489
题目链接：传送门 在太阳西斜的这个世界里，置身天上之森。等这场战争结束之后，不归之人与望眼欲穿的众人， 人人本着正义之名，长存不灭的过去、逐渐消逝的未来。我回来了，纵使日薄西山，即便看不到未来，此时此刻的光辉，盼君勿忘。 珂朵莉最可爱了，珂朵莉的题最毒瘤了qwq 然而这道题…… 首先这道题显然是莫队qwq。 把质数筛出来，把每个数大莉分解质因数。 若nnn分解质因数为p1a1∗p2a2∗...
[Ynoi2015]此时此刻的光辉
12-09 330
题目大意： 给定一个序列，每次询问一段区间的数的乘积的约数个数。 解题思路： 在太阳西斜的这个世界里，置身天上之森。等这场战争结束之后，不归之人与望眼欲穿的众人， 人人本着正义之名，长存不灭的过去、逐渐消逝的未来。我回来了，纵使日薄西山，即便看不到未来，此时此刻的光辉，盼君勿忘。————世界上最幸福的女孩 我永远喜欢珂朵莉。 --- \(10^9\)以内的数最多有10个不同的...
[Ynoi2015]我回来了
weixin_30248399的博客
12-10 86
题目大意： 给定一张无向无权图，每次给定若干个二元组\((x_i,y_i)\)，定义点\(u\)满足条件，当且仅当存在\(i\)，并满足\(dist(u,x_i)\leqslant y_i\)（\(dist(u,v)\)表示\(u,v\)两点的距离）。每次询问求满足条件的点个数。 解题思路： 在太阳西斜的这个世界里，置身天上之森。等这场战争结束之后，不归之人与望眼欲穿的众人， 人人本着正义之...
关于日薄西山的造句参考.doc
09-16
关于日薄西山的造句参考.doc
UML正日薄西山的13个理由
05-19
然而，随着时间的推移，UML似乎正在失去其在开发者社区中的影响力，这可以从“UML正日薄西山的13个理由”中看出。以下是对这些理由的详细分析： 1. **由委员会设计**：如同许多由大型委员会制定的标准，UML可能因...
2015_2016八年级语文上册20落日的幻觉课件新人教版
09-10
文章中提到的“日薄西山，气息奄奄”，是对落日景象的另一种艺术表达。"日薄西山"形象地描绘了太阳即将下山的情景，暗喻事物的衰败或人的衰老；"气息奄奄"则用来形容夕阳的余晖，同时也隐喻生命的衰退或事物的消亡。...
2015_2016八年级语文上册20落日的幻觉练习2新版新人教版
08-06
1. **汉字读音和词义**：学习中涉及了汉字的注音和词汇的理解，例如“奄奄（yǎn）”、“绮丽（qǐ lì）”、“衰减（shuāi jiǎn）”等词的发音，以及“日薄西山”（形容太阳即将落山）和“绮丽”（形容景色鲜艳...
Ynoi 做题记录
FuDuoDuo_qwq的博客
10-25 117
为了方便处理，我们先将相邻两个数对应区间的答案作为线段树叶子结点对应的区间。然后在线段树上维护一个类似 dp 的数组。，表示区间最左端和最右端的数 没有被覆盖 / 被覆盖 / 是极大值。所以只需要关注操作中心的集合就可以了。然后我们考虑用线段树维护。然后类似 dp 地在线段树上合并。减一的操作一直进行到。，不会改变最终答案。
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
最新发布
qq_61936886的博客
09-12 448
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;2.递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
算法知识点——常用输入输出数据的方式
5233的博客
09-12 257
除了换行之外，还会清空缓存区，而清空缓存区这件事情会耗时很久，因此为了提高速度，一般直接：cout << “\n”;2、n组输入输出(n不确定）1、n组输入输出(n确定）3、 复杂的输入输出。
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1146
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
算法基础-约数
qq_65186476的博客
09-11 293
试除法求约数、约数个数、约数之和、最大公约数
算法练习题24——查找杨辉三角中的组合数
hello77的blogggg 祝你得偿所愿
09-12 553
逐项递推法适合处理较小的数据量，计算较为直观，但当杨辉三角行数较大时，效率较低。 二分查找法利用组合数的单调性，显著提高查找效率，适合处理较大的数据范围。这两种解法在不同场景下都可以使用，二分查找法尤其适合大规模数据下的查找问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值