2022杭电多校——2

最新推荐文章于 2023-07-30 16:07:39 发布
最新推荐文章于 2023-07-30 16:07:39 发布
阅读量155 收藏
点赞数 1
分类专栏： 题解 文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZVAF_/article/details/126050949
版权

Static Query on Tree（树链剖分）

问题可以转化为求三个集合的交集

const int N=2e5+10,M=2*N;
int n,q;
int h[N],e[M],ne[M],idx;
int fa[N],siz[N],son[N],dep[N];
int id[N],rid[N],top[N],num;
void add(int a,int b){
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
void dfs1(int u,int f){
    son[u]=0;
    fa[u]=f;siz[u]=1;
    dep[u]=dep[f]+1;
    for(int i=h[u];~i;i=ne[i]){
        int j=e[i];
        if(j==f) continue;
        dfs1(j,u);
        siz[u]+=siz[j];
        if(!son[u]||siz[j]>siz[son[u]]) son[u]=j;
    }
}
void dfs2(int u,int t){
    id[u]=++num,rid[num]=u,top[u]=t;
    if(!son[u]) return ;
    dfs2(son[u],t);
    for(int i=h[u];~i;i=ne[i]){
        int j=e[i];
        if(j==fa[u]||j==son[u]) continue;
        dfs2(j,j);
    }
}
void join(int a,int b,vector<PII>&ve){//点加入集合
    while(top[a]!=top[b]){
        if(dep[top[a]]<dep[top[b]]) swap(a,b);
        ve.push_back({id[top[a]],id[a]});
        a=fa[top[a]];
    }
    if(dep[a]<dep[b]) swap(a,b);
    ve.push_back({id[b],id[a]});
}
void merge(vector<PII>&ve){//合并集合内重复区间
    if(!ve.size()) return ;
    vector<PII>t;
    sort(ve.begin(),ve.end());
    int st=ve[0].l,ed=ve[0].r;
    for(auto i:ve){
        if(i.l>ed){
            t.push_back({st,ed});
            st=i.l,ed=i.r;
        }
        else ed=max(ed,i.r);
    }
    t.push_back({st,ed});
    ve=t;
}
vector<PII> intersection(vector<PII>a,vector<PII>b){//集合合并
    vector<PII>ve;
    int i=0,j=0;
    while(i<a.size()&&j<b.size()){
        int l=max(a[i].l,b[j].l);
        int r=min(a[i].r,b[j].r);
        if(l<=r) ve.push_back({l,r});
        if(a[i].r<b[j].r) i++;
        else j++;
    }
    return ve;
}
void solve(){
    cin>>n>>q;

    idx=num=0;
    for(int i=1;i<=n;i++) h[i]=-1;

    for(int i=2;i<=n;i++){
        int x; cin>>x;
        add(x,i),add(i,x);
    }
    dfs1(1,0);dfs2(1,1);
    while(q--){
        vector<PII>a,b,c;
        int x,y,z,u;cin>>x>>y>>z;
        while(x--){
            cin>>u;
            join(1,u,a);
        }
        while(y--){
            cin>>u;
            join(1,u,b);
        }
        while(z--){
            cin>>u;
            c.push_back({id[u],id[u]+siz[u]-1});
        }
        merge(a);merge(b),merge(c);
        a=intersection(a,b);
        a=intersection(a,c);
        int res=0;
        for(auto i:a){
            res+=i.r-i.l+1;
        }
        cout<<res<<endl;
    }
}

Copy（离线+bitset优化）

离线操作，正向枚举询问不容易做，考虑反向枚举

每次是使[l,r]插入到r的后面，

当选择的位置x<=r时反向正向没有区别，

当x>r时，需要将反向查询的位置向左偏移r-l+1（向下标小的位置偏移）

题目求得时异或值，只需要记录是否出现过奇数次，所以可以用bitset判断每个位置的出现次数，并实现O(1)修改偏移量

const int N=1e5+10;
int n,m;
int g[N],q[N][3];
bitset<N>f,low,high;
inline void solve(){
    cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>g[i];
    for(int i=0;i<m;i++){
        cin>>q[i][0]>>q[i][1];
        if(q[i][0]==1) cin>>q[i][2];
    }
    f.reset();
    for(int i=m-1;i>=0;i--){
        if(q[i][0]==1){
            int l=q[i][1],r=q[i][2];
            //将f分为[1,r],[r+1,n]两部分
        
            low=f&(~bitset<N>(0)>>(N-(r+1)));//前r+1位，因为第一位下标为0
            high=f&(~bitset<N>(0)<<(r+1));//r+1~n
            f=low^(high>>(r-l+1));
        }
        else{
            int x=q[i][1];
            f[x]=!f[x];
        }
    }
    int ans=0;
    for(int i=1;i<=n;i++){
        if(f[i]) ans^=g[i];
    }
    cout<<ans<<endl;
}

DOS Card（线段树+暴力）

巧妙的做法

把所有情况表示出来：

求++--或则+-+-的最大值

维护出所有能更新成上述两种情况的max

+ -
++ --
+- -+
++- +--
+-+ -+-

const int N=2e5+10;
int n,m,g[N];
struct P{
    int l,r;
    int res1,res2;//++-- +-+-
    int a,b;//+ -
    int c,d;//++ --
    int e,f;//+- -+
    int g,h;//++- +--
    int i,j;//+-+ -+-
    void init(int ll,int rr){
        l=ll,r=rr;
        res1=res2=a=b=c=d=e=f=g=h=i=j=-INF;
    }
}tr[4*N];
void pushup(P &u,P l,P r){
    u.res1=max(l.res1,r.res1);
    u.res2=max(l.res2,r.res2);
    u.a=max(l.a,r.a);
    u.b=max(l.b,r.b);
    u.c=max(l.c,r.c);
    u.d=max(l.d,r.d);
    u.e=max(l.e,r.e);
    u.f=max(l.f,r.f);
    u.g=max(l.g,r.g);
    u.h=max(l.h,r.h);
    u.i=max(l.i,r.i);
    u.j=max(l.j,r.j);

    u.res1=max(u.res1,l.a+r.h);
    u.res1=max(u.res1,l.c+r.d);
    u.res1=max(u.res1,l.g+r.b);
    u.res2=max(u.res2,l.e+r.e);
    u.res2=max(u.res2,l.a+r.j);
    u.res2=max(u.res2,l.i+r.b);

    u.c=max(u.c,l.a+r.a);
    u.d=max(u.d,l.b+r.b);
    u.e=max(u.e,l.a+r.b);
    u.f=max(u.f,l.b+r.a);
    u.g=max(u.g,l.c+r.b);
    u.g=max(u.g,l.a+r.e);
    u.h=max(u.h,l.a+r.d);
    u.h=max(u.h,l.e+r.b);
    u.i=max(u.i,l.e+r.a);
    u.i=max(u.i,l.a+r.f);
    u.j=max(u.j,l.b+r.e);
    u.j=max(u.j,l.f+r.b);
}
void pushup(int u){
    pushup(tr[u],tr[u<<1],tr[u<<1|1]);
}
void build(int u,int l,int r){
    tr[u].init(l,r);
    if(l==r) tr[u].a=g[l],tr[u].b=-g[l];
    else{
        int mid=l+r>>1;
        build(u<<1,l,mid),build(u<<1|1,mid+1,r);
        pushup(u);
    }
}
P query(int u,int l,int r){
    if(tr[u].l>=l&&tr[u].r<=r) return tr[u];
    int mid=tr[u].l+tr[u].r>>1;
    if(r<=mid) return query(u<<1,l,r);
    if(l>mid) return query(u<<1|1,l,r);
    P root;
    root.init(0,0);
    pushup(root,query(u<<1,l,r),query(u<<1|1,l,r));
    return root;
}
inline void solve(){
    cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>g[i],g[i]*=g[i];
    build(1,1,n);
    while(m--){
        int l,r; cin>>l>>r;
        P u=query(1,l,r);
        cout<<max(u.res1,u.res2)<<endl;
    }
}

Slayers Come（线段树维护dp+并查集+双指针）

先预处理出选择每个技能对应能杀死的怪物的区间

处理后问题转换为在m个技能中选择可以将整个区间覆盖（每个点可覆盖任意多次）的方案数

dp[i]表示将区间[1,i]覆盖的方案数
对于每个区间[l,r]
dp[r]+=dp[l-1~r](l-1到r的方案数)
因为先前更新的dp未考虑当前区间
所以
dp[1~l-2]*=2(1到l-2未考虑当前区间)

对一个区间乘，单点加，区间查询可以使用线段树

如果处理出区间？

对于右端点

a [ i ] − r [ j ] > = b [ i + 1 ] ⇒ a [ i ] − b [ i + 1 ] > = r [ j ] a[i]-r[j]>=b[i+1]\Rightarrow a[i]-b[i+1]>=r[j] a[i]−r[j]>=b[i+1]⇒a[i]−b[i+1]>=r[j]

设 s [ i ] = a [ i ] − b [ i + 1 ] s[i]=a[i]-b[i+1] s[i]=a[i]−b[i+1]，对s递增排序，对r递减排序

若当前 s [ i ] > r [ j ] s[i]>r[j] s[i]>r[j]，说明选择技能j可以杀死怪物i（需要求出对应的排序前的位置）

因为r递减，所以后面的技能一定满足杀死当前怪物（双指针）

只需找出来每个怪物之间是否来连通，用并查集维护每个怪物之间的关系

左端点同理

const int N=1e5+10;
int n,m;
int a[N],b[N],f[N];
PII s[N];
struct P{
    int l,r,v;
    int ll,rr;
}g[N];
struct Node{
    int l,r;
    int sum;
    int lazy;
}tr[4*N];
int find(int x){
    return f[x]==x?f[x]:f[x]=find(f[x]);
}
void pushdown(int u){
    Node &root=tr[u],&left=tr[u<<1],&right=tr[u<<1|1];
    if(root.lazy!=1){
        left.sum=left.sum*root.lazy%mod;
        right.sum=right.sum*root.lazy%mod;
        left.lazy=left.lazy*root.lazy%mod;
        right.lazy=right.lazy*root.lazy%mod;
        root.lazy=1;
    }
}
void pushup(int u){
    tr[u].sum=(tr[u<<1].sum+tr[u<<1|1].sum)%mod;
}
void build(int u,int l,int r){
    tr[u]={l,r,0,1};
    if(l!=r){
        int mid=l+r>>1;
        build(u<<1,l,mid),build(u<<1|1,mid+1,r);
        pushup(u);
    }
}
void add(int u,int x,int v){
    if(tr[u].l==x&&tr[u].r==x){
        tr[u].sum=(tr[u].sum+v)%mod;
        return ;
    }
    pushdown(u);
    int mid=tr[u].l+tr[u].r>>1;
    if(x<=mid) add(u<<1,x,v);
    else add(u<<1|1,x,v);
    pushup(u);
}
void mul(int u,int l,int r){
    if(tr[u].l>=l&&tr[u].r<=r){
        tr[u].sum=tr[u].sum*2%mod;
        tr[u].lazy=tr[u].lazy*2%mod;
        return ;
    }
    pushdown(u);
    int mid=tr[u].l+tr[u].r>>1;
    if(l<=mid) mul(u<<1,l,r);
    if(r>mid) mul(u<<1|1,l,r);
    pushup(u);
}
int query(int u,int l,int r){
    if(tr[u].l>=l&&tr[u].r<=r) return tr[u].sum;
    pushdown(u);
    int mid=tr[u].l+tr[u].r>>1;
    int res=0;
    if(l<=mid) res+=query(u<<1,l,r);
    if(r>mid) res+=query(u<<1|1,l,r);
    res%=mod;
    return res;
}
inline void solve(){
    cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>a[i]>>b[i];
    for(int i=1;i<=m;i++){
        int l,r,v; cin>>v>>l>>r;
        g[i]={l,r,v};
    }

    for(int i=1;i<=n;i++) f[i]=i;
    for(int i=1;i<n;i++) s[i]={a[i]-b[i+1],i};
    sort(s+1,s+n);
    sort(g+1,g+1+m,[](P &x,P &y){
        return x.r>y.r;
    });
    for(int i=1,j=n-1;i<=m;i++){
        while(j>=1&&s[j].x>=g[i].r){
            int pos=s[j].y;
            f[pos]=pos+1;
            j--;
        }
        g[i].rr=find(g[i].v);
    }

    for(int i=1;i<=n;i++) f[i]=i;
    for(int i=1;i<n;i++) s[i]={a[i+1]-b[i],i};
    sort(s+1,s+n);
    sort(g+1,g+1+m,[](P &x,P &y){
         return x.l>y.l;
    });
    for(int i=1,j=n-1;i<=m;i++){
        while(j>=1&&s[j].x>=g[i].l){
            int pos=s[j].y;
            f[pos+1]=pos;
            j--;
        }
        g[i].ll=find(g[i].v);
    }
    sort(g+1,g+1+m,[](P &x,P &y){
        return x.rr<y.rr;
    });
    //单点加，区间乘，区间和查询
    build(1,0,n);
    add(1,0,1);
    for(int i=1;i<=m;i++){
        int l=g[i].ll,r=g[i].rr;
       // cout<<l<<' '<<r<<endl;
        add(1,r,query(1,l-1,r));
        if(l>=2) mul(1,0,l-2);
    }
    cout<<query(1,n,n)<<endl;
}
_铁铁铁铁铁_
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
2018杭电多校第二场题解1
08-03
这篇题解涵盖了多个不同的编程竞赛题目，涉及到概率计算、图论、动态规划、组合数学以及字符串处理等多个领域的知识点。下面是对各个题目解法的详细解释： 1. **咕咕咕，咕咕咕 (Absolute)**: 此题是关于计算期望值...
2022新生赛A题——舌尖上的杭电.rar
11-26
2022新生赛A题——舌尖上的杭电.rar
2022杭电多校2(总结+补题)
m0_51028279的博客
07-21 780
多校总结+部分题解
2022杭电多校——1
ZVAF_的博客
07-28 368
我太菜了
2022杭电多校3——补题
ZVAF_的博客
07-27 260
太菜了
杭电多校——第二场（题解）
小王小王光吃不胖的博客
11-14 4024
太难的不会写，因为真的不会。。。 1010 Lead of Wisdom 现在在题目单中已经可以找到6772Lead of Wisdom 题目大意 有t个测试案例 每个案例首先会有n,k，n代表接下来的n行会有n把武器，每个武器是不同的种类，并且均拥有a，b，c，d四种属性，k代表最多可以出现的武器种类最多有k种。 每种武器最多只能拿一把，也就是说当每一种武器都有的时候最多可以拿k把武器，如果有的武器种类没有就不能拿这种，所以武器数一定 <= k 需要求的值为 分析 这题解法很暴力，就是把每一种情况的
2022杭电多校 第三场 B题 Boss Rush
m0_51171995的博客
08-02 186
二分+状压DP
2022杭电多校4(总结+补题)
m0_51028279的博客
07-28 436
今天开局看1004过了一车人，跟队友一会大胆猜测全部都是No，直接莽了一发过了，然后队友开1006我开1007，队友10min过1006，我写一半发现1007读假题看复杂了，重新思考后一发过了1007，两个队友继续看1001，我开1002图论，写了一发t了，又写了几发优化了常数，还是t，遂让队友用奇技淫巧——卡时，卡了三次之后莫名其妙的过了1002，然后队友又看出1011线性基，一发又秒了，五题，我继续找图论1005，队友看1001，最后10min队友过了1001，我没做出来1005，6题结束。...
【多校训练】2023杭电多校4补题
最新发布
分享XCPC常用算法和相关技巧
07-30 522
2023hdu多校第四场
[思维]Ironforge 2022杭电多校第8场 1005
Cloth的博客
08-12 200
最后一个问题就是怎么判断能不能走到下一个城市了，这可以通过一个vector数组维护出来每个质因子出现的位置，然后二分查询，例如要想知道在区间[l, r]时能否移动至l-1，那就找一下l到l-1那条边的边权bi在vector[bi]中第一个大于等于l的位置，如果它小于等于r，那就说明这段区间内出现过bi，也就可以走过去。最后整个问题的时间复杂度为O(nlogn)。...
2022 年杭电多校第二场补题记录
m0_52048145的博客
07-22 569
2022 年杭电多校第二场补题记录
杭电数据结构07——11年
08-25
数据结构作为参考类型，年份是从07到11年的考研资料。
2019-hdu-multi-（2019杭电多校第二场数据与标程）.zip
08-01
这份压缩爆内包含了2019年杭电多校第二场的数据与标程，欢迎下载
杭电计组实验3多功能ALU设计实验
04-22
多功能ALU设计实验报告 本实验报告介绍了杭州电子科技大学计算机学院计算机组成原理与系统结构课程设计的实验报告，实验名称为多功能ALU设计实验。实验的目的是学习多功能ALU的工作原理，掌握运算器的设计方法，...
“统信杯” 第十七届黑龙江省大学生程序设计竞赛 Let‘s Swap
ZVAF_的博客
05-16 1322
Let’s Swap（思维+hash）4星 题意： 已知一个长度为n的字符串SSS，可以对字符串进行一种操作： 将字符串SSS从下标i(1≤i≤n)i(1\leq i\leq n)i(1≤i≤n)的位置将串分为两个串A、BA、BA、B 将字符串SSS变为BABABA 反转字符串SSS 给你两个数a、ba、ba、b代表可以选取的下标的位置，允许操作任意次（或不操作） 问SSS是否可以通过操作变成目标串CCC 多组输入 1≤T,sum∣S∣≤5∗5101\leq T,sum|S|\leq 5*5^{10}1
GDCPC广东省大学生程序设计竞赛部分题解
ZVAF_的博客
05-14 1226
Industrial Nuclear Water（计算几何）3星 题意： 给你两个点，问这两个点是否在所给三个面的同一侧 1000∣x∣=y2+z2,1000∣y∣=x2+z2,1000∣z∣=x2+y21000|x|=y^2+z^2,1000|y|=x^2+z^2,1000|z|=x^2+y^21000∣x∣=y2+z2,1000∣y∣=x2+z2,1000∣z∣=x2+y2 题解： 判断两点是否在一个面的同一侧，只需将点带入方程看结果是否符号一致 #include<bits/stdc++.h&gt
2021辽宁省大学生程序设计竞赛
ZVAF_的博客
05-14 809
比赛!（差分约束+虚拟源点）4星 题意： 按照a:bca:bca:bc的形式给你三个队伍的顺序（b>=a>=cb>=a>=cb>=a>=c），输出一种满足所有输入的方案，否则返回No Answer 题解： 注意可能题目给的队伍不完全联通，需要用虚拟源点连接 一定要能从源点出发走到所有点 最短路 #include<bits/stdc++.h> using namespace std; const int N=510; string s; int n,cnt=0;
2021 年第十三届四川省 ACM-ICPC 大学生程序设计竞赛
ZVAF_的博客
05-14 617
Spicy Restaurant（多元BFS）4星 题意： 给你一个nnn个点mmm条边的无向图，每个点有一个权值www，qqq次询问问从点aaa出发走到权值小于等于bbb的点的最小距离，不能满足输出-1 1≤n,m≤1051\leq n,m\leq 10^51≤n,m≤105 1≤wi,bi≤1001\leq w_i,b_i\leq 1001≤wi​,bi​≤100 1≤ai≤n1\leq a_i\leq n1≤ai​≤n 题解： 因为权值的范围比较小，所以我们可以按照权值跑BFS记录每种情况每个点到权值
2023年杭电多校-3
07-28
- *1* *3* [2022杭电多校1(总结+补题)](https://blog.csdn.net/m0_51028279/article/details/125892082)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值