2053: Peach Conference

最新推荐文章于 2024-08-08 15:12:59 发布
最新推荐文章于 2024-08-08 15:12:59 发布
阅读量175 收藏
点赞数
分类专栏： 线段树 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45724872/article/details/120190927
版权

题目来源

题面

在这里插入图片描述
在这里插入图片描述

思路一、

将清空操作视为区间最小值操作
不知道区间操作点我

#include <iostream>
 
#define lc (p<<1)
#define rc (p<<1|1)
 
using namespace std;
 
const int N = 1e5+10;
 
typedef long long ll;
struct Node{
    int l,r,mx,sec_mx,mx_num;
    int mx_tag,other_tag;
    ll sum;
}tr[N<<2];
 
int a[N],t,n,m;
void push_down(int p);
void push_up(int p){
    tr[p].sum = tr[lc].sum + tr[rc].sum;
    if(tr[lc].mx == tr[rc].mx){
        tr[p].mx = tr[lc].mx;
        tr[p].mx_num = tr[lc].mx_num + tr[rc].mx_num;
        tr[p].sec_mx = max(tr[lc].sec_mx,tr[rc].sec_mx);
    }else if(tr[lc].mx > tr[rc].mx){
        tr[p].mx = tr[lc].mx;
        tr[p].mx_num = tr[lc].mx_num;
        tr[p].sec_mx = max(tr[lc].sec_mx,tr[rc].mx);
    }else{
        tr[p].mx = tr[rc].mx;
        tr[p].mx_num = tr[rc].mx_num;
        tr[p].sec_mx = max(tr[rc].sec_mx,tr[lc].mx);
    }
}
void build(int p,int l,int r){
    tr[p].l = l,tr[p].r = r;
    tr[p].sec_mx = -1;//因为数据范围是从0开始的
    tr[p].mx_tag = tr[p].other_tag = 0;
    if(l == r){
        tr[p].sum = tr[p].mx = a[l];
        tr[p].mx_num = 1;
        return;
    }
    int mid = (l+r) >> 1;
    build(lc,l,mid);
    build(rc,mid+1,r);
    push_up(p);
}
//给这个节点的最大值、其他值加上某些数
void node_update_fun(int p,int mxk,int otherk){
    tr[p].sum += 1ll*mxk*tr[p].mx_num + 1ll*(tr[p].r-tr[p].l+1-tr[p].mx_num)*otherk;
    if(tr[p].sec_mx != -1) tr[p].sec_mx += otherk;
    tr[p].mx += mxk;
    tr[p].mx_tag += mxk;
    tr[p].other_tag += otherk;
}
void range_min_fun(int p,int l,int r,int k){
    if(k>=tr[p].mx) return;
    if(tr[p].l>=l&&tr[p].r<=r&&tr[p].sec_mx < k){
        node_update_fun(p,k-tr[p].mx,0);
        return;
    }
    push_down(p);
    int mid = (tr[p].l + tr[p].r) >> 1;
    if(r<=mid){
        range_min_fun(lc,l,r,k);
    }else if(l>mid){
        range_min_fun(rc,l,r,k);
    }else{
        range_min_fun(lc,l,mid,k);
        range_min_fun(rc,mid+1,r,k);
    }
    push_up(p);
}
void push_down(int p){
    int mxk = tr[p].mx_tag;
    int otherk = tr[p].other_tag;
    int mx = max(tr[lc].mx,tr[rc].mx);
    //分清楚左右儿子的值到底应该被哪个k所加
    node_update_fun(lc,tr[lc].mx==mx?mxk:otherk,otherk);
    node_update_fun(rc,tr[rc].mx==mx?mxk:otherk,otherk);
    tr[p].mx_tag = tr[p].other_tag = 0;
}
ll query_sum(int p,int l,int r){
    if(tr[p].l>=l&&tr[p].r<=r){
        return tr[p].sum;
    }
    push_down(p);
    int mid = (tr[p].l+tr[p].r)>>1;
    if(r<=mid){
        return query_sum(lc,l,r);
    }else if(l>mid){
        return query_sum(rc,l,r);
    }else{
        return query_sum(lc,l,mid) +
        query_sum(rc,mid+1,r);
    }
}
void range_add_fun(int p,int l,int r,int k){
    if(tr[p].l>=l&&tr[p].r<=r){
        node_update_fun(p,k,k);
        return;
    }
    push_down(p);
    int mid = (tr[p].l + tr[p].r) >> 1;
    if(r<=mid){
        range_add_fun(lc,l,r,k);
    }else if(l > mid){
        range_add_fun(rc,l,r,k);
    }else{
        range_add_fun(lc,l,mid,k);
        range_add_fun(rc,mid+1,r,k);
    }
    push_up(p);
}
int main(){
    std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    ll n,q;
    cin >> n >> q;
    for(ll i=1;i<=n;++i) a[i] = 0;
    build(1,1,n);
    ll l,r,m;
    while(q--){
        cin >> m >> l >> r;
        if(m==0 && l&1 && r&1){
            //区间清空
            range_min_fun(1,l,r,0);
        }else{
             if(m == 0){
                 //区间和
                 cout << query_sum(1,l,r) << '\n';
             }else{
                 //区间加
                 range_add_fun(1,l,r,m);
             }
        }
    }
    return 0;
}
 
/**************************************************************
    Problem: 2053
    Language: C++
    Result: 正确
    Time:2066 ms
    Memory:18356 kb
****************************************************************/

思路二、

维护清空标记；

在push_down的时候，先执行clear标记，再执行add标记；

因为打上clear的同时，会将add清空；

如果再有标记，则说明是清空后的标记；

#include <iostream>

#define lc (p<<1)
#define rc (p<<1|1)

using namespace std;

const int N = 1e5+10;

typedef long long ll;

struct Node{
    int l,r;
    ll sum,add;
    bool clear;
}t[N<<2];

ll a[N];
void push_up(int p){
    t[p].sum = t[lc].sum + t[rc].sum;
}
void push_down(int p){
    auto & r = t[p];
    auto & left = t[lc];
    auto & right = t[rc];
    if(r.clear){
         left.sum = 0;
         right.sum = 0;
         left.add = right.add = 0;
         left.clear = right.clear = true;
         r.clear = false;
    }
    if(r.add){
         left.sum += 1ll*(left.r - left.l +1)*r.add;
         left.add += r.add;
         right.sum += 1ll*(right.r - right.l +1)*r.add;
         right.add +=r.add;
         r.add = 0;
    }
}
void build(int p,int l,int r){
    t[p].l = l,t[p].r = r;
    t[p].clear = false;
    if(l == r){
        t[p].sum = a[l];
        t[p].add = 0;
        return;
    }
    int mid = (l+r) >> 1;
    build(lc,l,mid);
    build(rc,mid+1,r);
    push_up(p);
}
void modify(int p,int l,int r,int d){
    if(t[p].l>=l&&t[p].r<=r){
        t[p].sum += (t[p].r-t[p].l+1)*d;
        t[p].add += d;
        return;
    }
    push_down(p);
    int mid = (t[p].l+t[p].r) >> 1;
    if(r<=mid) modify(lc,l,r,d);
    else if(l>mid) modify(rc,l,r,d);
    else{
        modify(lc,l,mid,d);
        modify(rc,mid+1,r,d);
    }
    push_up(p);
}
ll query(int p,int l,int r){
    if(t[p].l>=l&&t[p].r<=r){
        return t[p].sum;
    }
    push_down(p);
    int mid = (t[p].l+t[p].r) >> 1;
    if(r<=mid) return query(lc,l,r);
    else if(l>mid) return query(rc,l,r);
    else{
        return query(lc,l,mid) + query(rc,mid+1,r);
    }
}
void clear(int p,int l,int r){
     if(t[p].l>=l&&t[p].r<=r){
          t[p].sum = 0;
          t[p].add = 0;
          t[p].clear = true;
          return;
     }
     push_down(p);
     int mid = (t[p].l+t[p].r)>>1;
     if(r<=mid) clear(lc,l,r);
     else if(l>mid) clear(rc,l,r);
     else{
          clear(lc,l,mid);
          clear(rc,mid+1,r);
     }
    push_up(p);
}
int main(){
    std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    int n,q;
    cin >> n >> q;
    for(int i=1;i<=n;++i) a[i] = 0;
    build(1,1,n);
    int l,r,m;
    while(q--){
        cin >> m >> l >> r;
        if(m==0 && l&1 && r&1){
         clear(1,l,r);
        }else{
         if(m == 0){
          cout << query(1,l,r) << '\n';
         }else{
          modify(1,l,r,m);
         }
        }
    }
    return 0;
}

思路三、

维护两个标记，覆盖标记以及加法标记；

当有覆盖标记的时候，加法标记可以转化为覆盖标记；

代码部分待补；

#include <iostream>
 
#define lc (p<<1)
#define rc (p<<1|1)
 
using namespace std;
 
const int N = 1e5+10;
 
typedef long long ll;
 
const int INF = 0x3f3f3f3f;
 
int a[N];
 
struct Node{
    int l,r,add,cover;
    ll sum;
    bool cover_tag;
}tr[N<<2];
void push_up(int p){
    tr[p].sum = tr[lc].sum + tr[rc].sum;
}
//给某个区间加上k
void node_add(int p,int k){
    tr[p].sum += (tr[p].r-tr[p].l+1)*k;
    //如果有tag 则将add转化为cover操作
    if(tr[p].cover_tag){
        tr[p].cover += k;
    }else{
        tr[p].add += k;
    }
}
//将某个节点的值覆盖成k
void node_cover(int p,int k){
    tr[p].sum = (tr[p].r-tr[p].l+1) * k;
    tr[p].cover = k;
    tr[p].cover_tag = 1;
}
//先add再cover，因为如果有cover的话会将add转为cover
//见node_add部分代码
void push_down(int p){
    if(tr[p].add){
       node_add(lc,tr[p].add);
       node_add(rc,tr[p].add);
       tr[p].add = 0;
    }
    if(tr[p].cover_tag){
        node_cover(lc,tr[p].cover);
        node_cover(rc,tr[p].cover);
        tr[p].cover_tag = 0;
    }
}
void build(int p,int l,int r){
    tr[p].l = l,tr[p].r = r;
    if(l == r){
        tr[p].sum = a[l];
        return;
    }
    int mid = (l+r) >> 1;
    if(r<=mid){
        build(lc,l,r);
    }else if(l>mid){
        build(rc,l,r);
    }else{
        build(lc,l,mid);
        build(rc,mid+1,r);
    }
    push_up(p);
}
void range_cover(int p,int l,int r,int k){
    if(tr[p].l>=l&&tr[p].r<=r){
        node_cover(p,k);
        return;
    }
    push_down(p);
    int mid = (tr[p].l + tr[p].r) >> 1;
    if(r<=mid){
        range_cover(lc,l,r,k);
    }else if(l>mid){
        range_cover(rc,l,r,k);
    }else{
        range_cover(lc,l,mid,k);
        range_cover(rc,mid+1,r,k);
    }
    push_up(p);
}
void range_add(int p,int l,int r,int k){
    if(tr[p].l>=l&&tr[p].r<=r){
        node_add(p,k);
        return;
    }
    push_down(p);
    int mid = (tr[p].l + tr[p].r) >> 1;
    if(r<=mid){
        range_add(lc,l,r,k);
    }else if(l>mid){
        range_add(rc,l,r,k);
    }else{
        range_add(lc,l,mid,k);
        range_add(rc,mid+1,r,k);
    }
    push_up(p);
}
ll query_sum(int p,int l,int r){
    if(tr[p].l>=l&&tr[p].r<=r){
        return tr[p].sum;
    }
    push_down(p);
    int mid = (tr[p].l + tr[p].r) >> 1;
    if(r<=mid){
        return query_sum(lc,l,r);
    }else if(l>mid){
        return query_sum(rc,l,r);
    }else{
        return query_sum(lc,l,mid) +
        query_sum(rc,mid+1,r);
    }
}
int main(){
    std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    int n,q;
    cin >> n >> q;
    for(int i=1;i<=n;++i) a[i] = 0;
    build(1,1,n);
    int l,r,m;
    while(q--){
        cin >> m >> l >> r;
        if(m==0 && l&1 && r&1){
            range_cover(1,l,r,0);
        }else{
            if(m == 0){
                cout << query_sum(1,l,r) << '\n';
            }else{
                range_add(1,l,r,m);
            }
        }
    }
    return 0;
}
 
/**************************************************************
    Problem: 2053
    Language: C++
    Result: 正确
    Time:1102 ms
    Memory:15228 kb
****************************************************************/
荼白777
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
桃博客：:peach:基于烧瓶的博客
02-05
Peach Blog是基于Flask的博客平台，目的是为了提供一种更加纯粹的内容写作与发布平台，通过几个简单命令，可以帮助用户无痛的从Hexo切换到Peach Blog 产品特点 支持将hexo的帖子导出到数据库 支持将数据库的帖子...
fuzzing_notes:Peach Fuzzing Notes & Peach Pit Repository
06-20
练习 1 - 使用 Peach3 对 Vulnserver 进行模糊测试 运行桃坑验证： peach -t fuzzers\vulnserver_peachpit.xml 启动 Peach 远程代理（用于检测）： peach -a tcp 运行 Peach 模糊测试会话： peach fuzzers\...
江西省程序设计竞赛k题Peach Conference
qq_33269561的博客
10-24 597
qwq
第五届全国中医药院校大学生程序设计竞赛重现赛——题解
a23_23的博客
08-13 1080
目录A Jingwei Tian haiB Mona Lisa's smileC Morse CodeD Peach Conference（线段树+区间增加+区间修改+长整型输入输出 待补）E Shennong tastes all kinds of herbsF 冰冻三尺G 车神羲和H 大秦宝藏（DFS+剪枝 待补）I 韩信点兵J 纪昌学射K 夸父逐日（BFS+图论+单源最短路径 待补）L 团结军团（后缀自动机SAM+动态规划 待补） 放个我们重现赛的链接：HNUCM-OJ-第五届中医院校
2022江西icpc省赛k-Peach Conference
qq_61594973的博客
04-26 319
2022江西省赛-k,线段树问题
深度介绍：
weixin_33963189的博客
10-18 136
嘿！看看这几年啊，Web 前端的发展可是真快啊！想想几年前，HTML 是前端开发者的基本技能，通过各式各样的标签就可以搭建一个可用的网站，基本交互也不是问题。如果再来点 CSS，嗯，金黄酥脆，美味可口。这时候再撒上几把 JavaScript，简直让人欲罢不能。 随着需求的增长，HTML 的结构越来越复杂，大量重复的代码使得页面改动起来异常...
AFL++: Combining Incremental Steps of Fuzzing Research 翻译
大草的博客
01-20 2295
Combining Incremental Steps of Fuzzing Research 论文翻译
# Ultralytics 中文文档（六）
龙哥盟
08-08 577
VisDrone 数据集是中国天津大学 AISKYEYE 团队创建的大规模基准，旨在处理与无人机图像和视频分析相关的各种计算机视觉任务。其主要特点包括：-组成：288 个视频剪辑，261,908 帧和 10,209 张静态图像。注释：超过 260 万个边界框，用于行人、汽车、自行车和三轮车等对象。多样性：收集于 14 个城市，包括城市和农村设置，不同的天气和光照条件。任务：分为五个主要任务 - 图像和视频中的物体检测，单个和多个物体跟踪，以及人群计数。
提升你的阅读效率：背景颜色的重要性
qq_29824567的博客
05-31 1153
通过这项研究，我们了解到背景颜色对阅读的巨大影响。选择合适的背景颜色，不仅可以提高阅读速度，还能让阅读变得更加轻松愉快。希望这些建议能帮助你在日常生活中享受更好的阅读体验。
SitePoint播客＃119：在线社区圆桌会议
culh2177的博客
08-12 1104
Episode 119 of The SitePoint Podcast is now available! This week the panel is made up of regular host Patrick O’Keefe (@iFroggy) with guests Venessa Paech (@venessapaech), Sarah Hawk (@ilovethehawk) a...
asscroll:灰烬之卷轴:peach:
04-23
ASScroll是一种混合式平滑滚动设置，结合了虚拟滚动的性能提升以及本地滚动的可靠性。 此设置旨在成为一种轻量级解决方案，可在所有平台，设备和硬件上提供一致的平滑滚动体验。 相对于纯虚拟滚动的优势： ...
桃子：Peach是用于多语言，实时同步和可搜索文档的Web服务器
02-04
**桃子（Peach）——实时同步与可搜索文档的多语言Web服务器** Peach是一个功能强大的Web服务器，专门设计用于处理多语言文档，并提供实时同步和高效的搜索功能。其核心特性使得它成为开发者和团队协作的理想选择，...
martha::peach: 一小部分方便的 JavaScript 实用程序
07-24
玛莎 :peach: 一小部分方便的 JavaScript 实用程序。特征 :microscope: 小（<850b xss=removed xss=removed xss=removed> { console . log ( 'click!' ) } )}function unmount ( ) { // remove click handler from ...
P1145 约瑟夫
zty20120913的博客
08-06 418
n个人站成一圈，从某个人开始数数，每次数到m的人就被杀掉，然后下一个人重新开始数，直到最后只剩一个人。现在有一圈人，k个好人站在一起，k个坏人站在一起。从第一个好人开始数数。你要确定一个最小的m，使得在第一个好人被杀死前，k个坏人先被杀死。
C++初学者指南-5.标准库(第二部分)--数值运算算法
silencestarsky的博客
08-06 933
本文介绍了C++标准库中数值运算的相关算法，重点包括iota、reduce和各种扫描操作（scans），阐述了这些算法的用途、用法及其实现示例，并对并行执行的支持进行了说明。此外，文章还提到了一些遗留操作及其使用场景，为初学者理解C++标准库提供了实用的参考。
day 9 回溯算法
最新发布
m0_73924943的博客
08-08 246
优化后的比之前的在叶子结点少递归一层。在排序candidates后，碰到target<0的情况直接结束本层的遍历，后面没遍历到的也不用遍历了。1.目标数n一直在随i的加入减小，如果目标数n已经<0，那么剪枝。即path中的数已经大于目标数了。利用数组去重，因为题目的数值范围小，所以可以尽量使用。剪枝优化：（对每层循环遍历的范围进行了缩小）2.对for循环i的遍历范围进行缩小。也可以不用st数组去重。
day021二叉树最后章节
m0_62956971的博客
08-06 572
思路: 二叉搜索树的中序遍历就是有序升序数组，所以想要将它在转换成二叉树，我想到的方法就是通过递归来做，通过中间节点找到二叉搜索树的根节点，然后根据left和right双指针逐层递归构造左右子树。思路:最开始没有判断当当前节点小于最小值时，当前节点的右侧节点的情况，和当前节点大于最大值时，当前节点的左节点的情况，所以出错了，因此要在代码中判断一下这两种情况。思路: 累加树 由题意可知，在二叉搜索树中的递归顺序是右中左的顺序，创建一个新的函数，进行右中左的遍历，在遍历中要将节点的值记录下来，用来做累加。
CSP - J day7
2301_81608637的博客
08-06 187
答案具有单调性：对于正确答案 ans ，小于 ans 的都一定符合条件，大于 ans 的一定不符合条件，因此可以二分答案。先dfs到叶节点，再逐步递归出来，过程中节点数增加，一旦达到 mid ，ans 加一，同时向上贡献节点数变为零。
模糊测试入门：Peach框架深度解析与应用实战
本文主要介绍模糊测试技术及其应用，特别是开源模糊测试框架Peach的使用方法。模糊测试是一种通过构造异常输入数据引发软件异常，从而发现潜在安全问题的自动化测试技术。它具有广泛的适用性，特别是在漏洞挖掘领域...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值