BZOJ.4695.最假女选手(线段树 Segment tree Beats!)

最新推荐文章于 2021-09-11 23:21:11 发布
最新推荐文章于 2021-09-11 23:21:11 发布
阅读量164 收藏
点赞数
原文链接：http://www.cnblogs.com/SovietPower/p/9645911.html
版权

题目链接

区间取\(\max,\ \min\)并维护区间和是普通线段树无法处理的。
对于操作二，维护区间最小值\(mn\)、最小值个数\(t\)、严格次小值\(se\)。
当\(mn\geq x\)时，不需要改变，return；\(se>x>mn\)时，\(sum=sum+(x-mn)*t\)，打上区间\(\max\)标记；
当\(x\geq se>mn\)时，不会做，继续递归分别处理两个子区间，直到遇到前两种情况。
操作三同理，维护最大值、最大值个数、次大值。
复杂度\(O(m\log^2n)\)，常表现为\(O(m\log n)\)。通常叫做吉司机线段树。

[Update]
如果可以建值域线段树就好写多了。。（然而这题是区间查询）
对于取\(\max/\min\)操作可以直接区间修改清空超出范围的值，然后更新到对应位置上就行了（比如对\(v\)取\(\max\)，把\(\lt v\)的数全删掉，统计一下个数\(num\)，然后在\(v\)处加上\(num\)个\(v\)即可）。
复杂度\(m\log n\)，其实就是前/后缀的区间修改，也算和这题不太一样。
这样的题见BZOJ4399。

证明：（详见WC2016课件 Segment tree Beats!）
1143196-20180914124824486-1192831519.png
1143196-20180914124839975-181015390.png

细节：
有两个修改(\(\max,\ \min\))，太恶心了。。
比如：取\(\min\)的时候不仅是改最大值，最小值也可能改（当然了...然而写这题的时候就是忘了）。
最大值改了\(\min\)标记也一定改（最大值是算了当前\(\min\)标记后的）。
还有\(\max\)标记也可能改，注意是取\(\min\)而不是直接赋值（还有加法影响这个标记，原先的最大值并不一定是由这个标记得到的）。
还有\(\min,\ \max\)可能会使得区间变为同一个数(第一句话的情况)，这就需要特判然后把\(sum\),次小值,次大值初始化掉。
还有如果\(mn\)没有跟\(mx\)一起变为\(v\)(上一种情况)，但是可能\(mn<v\geq se\)，还要让次小值取个\(\min\)。

还有常数太大。。考虑把\(\min,\ \max\)标记去掉，直接在父节点更新，并在适合的时候下传：\(47s\to 40s\).

调到怀疑线段树。。感谢manchery dalao的代码。
https://blog.csdn.net/u014609452/article/details/54912473

吐槽：机房电脑都31s过，bzoj给我卡到47s。。虽然开了O2吧，但秀一波学校大机房配置：
1143196-20180914125346668-6668666.png
bzoj加油。

标记优化：

//79280kb   40460ms
#include <cstdio>
#include <cctype>
#include <algorithm>
//#define gc() getchar()
#define MAXIN 300000
#define gc() (SS==TT&&(TT=(SS=IN)+fread(IN,1,MAXIN,stdin),SS==TT)?EOF:*SS++)
typedef long long LL;
const int N=5e5+5,INF=2e9;

char IN[MAXIN],*SS=IN,*TT=IN;
inline int read()
{
    int now=0,f=1;register char c=gc();
    for(;!isdigit(c);c=='-'&&(f=-1),c=gc());
    for(;isdigit(c);now=now*10+c-'0',c=gc());
    return now*f;
}

struct Segment_Tree
{
    #define S N<<2
    #define ls rt<<1
    #define rs rt<<1|1
    #define lson l,m,rt<<1
    #define rson m+1,r,rt<<1|1
    int mn[S],smn[S],tmn[S],mx[S],smx[S],tmx[S],sz[S],add[S];
    LL sum[S];
    #undef S
    inline void Update(int rt)
    {
        int l=ls,r=rs; sum[rt]=sum[l]+sum[r];
        if(mn[l]<mn[r]) mn[rt]=mn[l],smn[rt]=std::min(smn[l],mn[r]),tmn[rt]=tmn[l];
        else if(mn[l]>mn[r]) mn[rt]=mn[r],smn[rt]=std::min(smn[r],mn[l]),tmn[rt]=tmn[r];
        else mn[rt]=mn[l],smn[rt]=std::min(smn[l],smn[r]),tmn[rt]=tmn[l]+tmn[r];

        if(mx[l]>mx[r]) mx[rt]=mx[l],smx[rt]=std::max(smx[l],mx[r]),tmx[rt]=tmx[l];
        else if(mx[l]<mx[r]) mx[rt]=mx[r],smx[rt]=std::max(smx[r],mx[l]),tmx[rt]=tmx[r];
        else mx[rt]=mx[l],smx[rt]=std::max(smx[l],smx[r]),tmx[rt]=tmx[l]+tmx[r];
    }
    inline void Add(int x,int v)
    {
        add[x]+=v, mn[x]+=v, mx[x]+=v, sum[x]+=1ll*v*sz[x];
        if(smn[x]!=INF) smn[x]+=v;
        if(smx[x]!=-INF) smx[x]+=v;
    }
    inline void Min(int x,int v)
    {
//      if(v<mx[x])
        sum[x]-=1ll*tmx[x]*(mx[x]-v);
        mx[x]=v, mn[x]=std::min(mn[x],v);//!
        if(mn[x]==mx[x]) sum[x]=1ll*sz[x]*v, tmn[x]=tmx[x]=sz[x], smn[x]=INF, smx[x]=-INF;//!
        else smn[x]=std::min(smn[x],v);//!
    }
    inline void Max(int x,int v)
    {
//      if(v>mn[x])
        sum[x]+=1ll*tmn[x]*(v-mn[x]);
        mn[x]=v, mx[x]=std::max(mx[x],v);
        if(mn[x]==mx[x]) sum[x]=1ll*sz[x]*v, tmn[x]=tmx[x]=sz[x], smn[x]=INF, smx[x]=-INF;
        else smx[x]=std::max(smx[x],v);
    }
    void PushDown(int rt)
    {
        int l=ls,r=rs;
        if(add[rt]) Add(l,add[rt]), Add(r,add[rt]), add[rt]=0;
        if(mx[l]>mx[rt] && mx[rt]>smx[l]) Min(l,mx[rt]);//下传之前的min 
        if(mx[r]>mx[rt] && mx[rt]>smx[r]) Min(r,mx[rt]);
        if(mn[l]<mn[rt] && mn[rt]<smn[l]) Max(l,mn[rt]);//下传之前的max 
        if(mn[r]<mn[rt] && mn[rt]<smn[r]) Max(r,mn[rt]);
    }
    void Build(int l,int r,int rt)
    {
        sz[rt]=r-l+1;
        if(l==r)
        {
            tmn[rt]=tmx[rt]=1;
            sum[rt]=mn[rt]=mx[rt]=read(), smn[rt]=INF, smx[rt]=-INF;
            return;
        }
        Build(l,l+r>>1,ls), Build((l+r>>1)+1,r,rs);
        Update(rt);
    }
    void Modify_Add(int l,int r,int rt,int L,int R,int v)
    {
        if(L<=l && r<=R) {Add(rt,v); return;}
        PushDown(rt);
        int m=l+r>>1;
        if(L<=m) Modify_Add(lson,L,R,v);
        if(m<R) Modify_Add(rson,L,R,v);
        Update(rt);
    }
    void Modify_Max(int l,int r,int rt,int L,int R,int v)
    {
        if(mn[rt]>=v) return;
        if(L<=l && r<=R && smn[rt]>v) {Max(rt,v); return;}
        PushDown(rt);
        int m=l+r>>1;
        if(L<=m) Modify_Max(lson,L,R,v);
        if(m<R) Modify_Max(rson,L,R,v);
        Update(rt);
    }
    void Modify_Min(int l,int r,int rt,int L,int R,int v)
    {
        if(mx[rt]<=v) return;
        if(L<=l && r<=R && smx[rt]<v) {Min(rt,v); return;}
        PushDown(rt);
        int m=l+r>>1;
        if(L<=m) Modify_Min(lson,L,R,v);
        if(m<R) Modify_Min(rson,L,R,v);
        Update(rt);
    }
    int Query_Max(int l,int r,int rt,int L,int R)
    {
        if(L<=l && r<=R) return mx[rt];
        PushDown(rt);
        int m=l+r>>1;
        if(L<=m)
            if(m<R) return std::max(Query_Max(lson,L,R),Query_Max(rson,L,R));
            else return Query_Max(lson,L,R);
        else return Query_Max(rson,L,R);
    }
    int Query_Min(int l,int r,int rt,int L,int R)
    {
        if(L<=l && r<=R) return mn[rt];
        PushDown(rt);
        int m=l+r>>1;
        if(L<=m)
            if(m<R) return std::min(Query_Min(lson,L,R),Query_Min(rson,L,R));
            else return Query_Min(lson,L,R);
        else return Query_Min(rson,L,R);
    }
    LL Query_Sum(int l,int r,int rt,int L,int R)
    {
        if(L<=l && r<=R) return sum[rt];
        PushDown(rt);
        int m=l+r>>1;
        if(L<=m)
            if(m<R) return Query_Sum(lson,L,R)+Query_Sum(rson,L,R);
            else return Query_Sum(lson,L,R);
        else return Query_Sum(rson,L,R);
    }
}T;

int main()
{
    #define S 1,n,1
    int n=read(); T.Build(S);
    for(int m=read(),opt,l,r; m--; )
    {
        opt=read(),l=read(),r=read();
        if(opt==1) T.Modify_Add(S,l,r,read());
        else if(opt==2) T.Modify_Max(S,l,r,read());
        else if(opt==3) T.Modify_Min(S,l,r,read());
        else if(opt==4) printf("%lld\n",T.Query_Sum(S,l,r));
        else if(opt==5) printf("%d\n",T.Query_Max(S,l,r));
        else printf("%d\n",T.Query_Min(S,l,r));
    }
    #undef S
    return 0;
}

无优化：（靠fread卡过）

//94908kb   47472ms
#include <cstdio>
#include <cctype>
#include <algorithm>
//#define gc() getchar()
#define MAXIN 300000
#define gc() (SS==TT&&(TT=(SS=IN)+fread(IN,1,MAXIN,stdin),SS==TT)?EOF:*SS++)
typedef long long LL;
const int N=5e5+5,INF=2e9;

char IN[MAXIN],*SS=IN,*TT=IN;
inline int read()
{
    int now=0,f=1;register char c=gc();
    for(;!isdigit(c);c=='-'&&(f=-1),c=gc());
    for(;isdigit(c);now=now*10+c-'0',c=gc());
    return now*f;
}

struct Segment_Tree
{
    #define S N<<2
    #define ls rt<<1
    #define rs rt<<1|1
    #define lson l,m,rt<<1
    #define rson m+1,r,rt<<1|1
    int mn[S],smn[S],tmn[S],mx[S],smx[S],tmx[S],sz[S],add[S],tagmn[S],tagmx[S];
    LL sum[S];
    #undef S
    inline void Update(int rt)
    {
        int l=ls,r=rs; sum[rt]=sum[l]+sum[r];
        if(mn[l]<mn[r]) mn[rt]=mn[l],smn[rt]=std::min(smn[l],mn[r]),tmn[rt]=tmn[l];
        else if(mn[l]>mn[r]) mn[rt]=mn[r],smn[rt]=std::min(smn[r],mn[l]),tmn[rt]=tmn[r];
        else mn[rt]=mn[l],smn[rt]=std::min(smn[l],smn[r]),tmn[rt]=tmn[l]+tmn[r];

        if(mx[l]>mx[r]) mx[rt]=mx[l],smx[rt]=std::max(smx[l],mx[r]),tmx[rt]=tmx[l];
        else if(mx[l]<mx[r]) mx[rt]=mx[r],smx[rt]=std::max(smx[r],mx[l]),tmx[rt]=tmx[r];
        else mx[rt]=mx[l],smx[rt]=std::max(smx[l],smx[r]),tmx[rt]=tmx[l]+tmx[r];
    }
    inline void Add(int x,int v)
    {
        add[x]+=v, mn[x]+=v, mx[x]+=v, sum[x]+=1ll*v*sz[x];
        if(smn[x]!=INF) smn[x]+=v;
        if(smx[x]!=-INF) smx[x]+=v;
        if(tagmn[x]!=INF) tagmn[x]+=v;
        if(tagmx[x]!=-INF) tagmx[x]+=v;
    }
    inline void Min(int x,int v)
    {
        if(v<mx[x])
        {
            sum[x]-=1ll*tmx[x]*(mx[x]-v);
            mx[x]=v, mn[x]=std::min(mn[x],v);//!
            tagmn[x]=v/*! 首先要比最大值小才可能（且一定会）更新min标记*/,
            tagmx[x]=std::min(tagmx[x],v);//!
            if(mn[x]==mx[x]) sum[x]=1ll*sz[x]*v, tmn[x]=tmx[x]=sz[x], smn[x]=INF, smx[x]=-INF;//!
            else smn[x]=std::min(smn[x],v);//!
        }
    }
    inline void Max(int x,int v)
    {
        if(v>mn[x])
        {
            sum[x]+=1ll*tmn[x]*(v-mn[x]);
            mn[x]=v, mx[x]=std::max(mx[x],v);
            tagmx[x]=v, tagmn[x]=std::max(tagmn[x],v);
            if(mn[x]==mx[x]) sum[x]=1ll*sz[x]*v, tmn[x]=tmx[x]=sz[x], smn[x]=INF, smx[x]=-INF;
            else smx[x]=std::max(smx[x],v);
        }
    }
    void PushDown(int rt)
    {
        if(add[rt]) Add(ls,add[rt]), Add(rs,add[rt]), add[rt]=0;
        if(tagmn[rt]!=INF) Min(ls,tagmn[rt]), Min(rs,tagmn[rt]), tagmn[rt]=INF;
        if(tagmx[rt]!=-INF) Max(ls,tagmx[rt]), Max(rs,tagmx[rt]), tagmx[rt]=-INF;
    }
    void Build(int l,int r,int rt)
    {
        sz[rt]=r-l+1, tagmn[rt]=INF, tagmx[rt]=-INF;
        if(l==r)
        {
            tmn[rt]=tmx[rt]=1;
            sum[rt]=mn[rt]=mx[rt]=read(), smn[rt]=INF, smx[rt]=-INF;
            return;
        }
        Build(l,l+r>>1,ls), Build((l+r>>1)+1,r,rs);
        Update(rt);
    }
    void Modify_Add(int l,int r,int rt,int L,int R,int v)
    {
        if(L<=l && r<=R) {Add(rt,v); return;}
        PushDown(rt);
        int m=l+r>>1;
        if(L<=m) Modify_Add(lson,L,R,v);
        if(m<R) Modify_Add(rson,L,R,v);
        Update(rt);
    }
    void Modify_Max(int l,int r,int rt,int L,int R,int v)
    {
        if(mn[rt]>=v) return;
        if(L<=l && r<=R && smn[rt]>v) {Max(rt,v); return;}
        PushDown(rt);
        int m=l+r>>1;
        if(L<=m) Modify_Max(lson,L,R,v);
        if(m<R) Modify_Max(rson,L,R,v);
        Update(rt);
    }
    void Modify_Min(int l,int r,int rt,int L,int R,int v)
    {
        if(mx[rt]<=v) return;
        if(L<=l && r<=R && smx[rt]<v) {Min(rt,v); return;}
        PushDown(rt);
        int m=l+r>>1;
        if(L<=m) Modify_Min(lson,L,R,v);
        if(m<R) Modify_Min(rson,L,R,v);
        Update(rt);
    }
    int Query_Max(int l,int r,int rt,int L,int R)
    {
        if(L<=l && r<=R) return mx[rt];
        PushDown(rt);
        int m=l+r>>1;
        if(L<=m)
            if(m<R) return std::max(Query_Max(lson,L,R),Query_Max(rson,L,R));
            else return Query_Max(lson,L,R);
        else return Query_Max(rson,L,R);
    }
    int Query_Min(int l,int r,int rt,int L,int R)
    {
        if(L<=l && r<=R) return mn[rt];
        PushDown(rt);
        int m=l+r>>1;
        if(L<=m)
            if(m<R) return std::min(Query_Min(lson,L,R),Query_Min(rson,L,R));
            else return Query_Min(lson,L,R);
        else return Query_Min(rson,L,R);
    }
    LL Query_Sum(int l,int r,int rt,int L,int R)
    {
        if(L<=l && r<=R) return sum[rt];
        PushDown(rt);
        int m=l+r>>1;
        if(L<=m)
            if(m<R) return Query_Sum(lson,L,R)+Query_Sum(rson,L,R);
            else return Query_Sum(lson,L,R);
        else return Query_Sum(rson,L,R);
    }
}T;

int main()
{
    #define S 1,n,1
    int n=read(); T.Build(S);
    for(int m=read(),opt,l,r; m--; )
    {
        opt=read(),l=read(),r=read();
        if(opt==1) T.Modify_Add(S,l,r,read());
        else if(opt==2) T.Modify_Max(S,l,r,read());
        else if(opt==3) T.Modify_Min(S,l,r,read());
        else if(opt==4) printf("%lld\n",T.Query_Sum(S,l,r));
        else if(opt==5) printf("%d\n",T.Query_Max(S,l,r));
        else printf("%d\n",T.Query_Min(S,l,r));
    }
    #undef S
    return 0;
}

转载于:https://www.cnblogs.com/SovietPower/p/9645911.html

weixin_30569001
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
bzoj 3730. 震波（动态点分治 + vector树状数组）
01-06
（自己写的动态点分治巨垃圾，常数是别人的两倍） 用动态开点线段树死活过不去，学了一波大佬用 vector 开树状数组立马就卡过去了 考虑点分树的做法，在点分树上每个点以距离为下标建一棵线段树，每次询问查询子树的贡献，再暴力向上跳合并父节点来自其它节点的贡献。 因为子树树形被破坏，在做减法时，子节点子树对父节点的贡献不能用子树维护的信息 + 连向父节点的边的贡献得到，考虑在每个节点再维护一个线段树，按距离建树用来统计子树内的节点到其父节点距离为 p 的点权和，这样便可以暴力爬树统计子树外的节点的贡献。 理论复杂度为 O(nlog⁡2n)O(n \log^2 n)O(nlog2n)，但常数巨大，况
BZOJ4695：最假女选手
aga28832的博客
01-06 145
浅谈区间最值操作和历史最值问题：https://www.cnblogs.com/AKMer/p/10225100.html 题目传送门：https://lydsy.com/JudgeOnline/problem.php?id=4695 吉司机线段树板子大集合。所有信息都封装在一个结构体里会比开多个数组快14秒。 注意暴力\(dfs\)子树时要\(pushdown\)。 时间复杂度：\(O...
bzoj4695 最佳女选手
a12377978的博客
09-11 163
bzoj4695 最佳女选手 题意： 给定一个序列，让我们实现六种操作 区间[l, r] 加 x 区间[l, r] 里小于x的数变成x 区间[l, r] 里大于x的数变成x 区间[l, r] 求和 区间 [l, r] 求max 区间 [l, r] 求min 题解： ​ 对于区间加维护一个tag即可，区间求和、求max、求min都是基本操作，这里要考虑对于2，3两个操作怎么去维护？ ​ 想一些比较特殊的情况来剪枝，来降低复杂度，对于操作2来说如果当前区间[l, r] 的 最小值mn都大于x我们就不需要
【bzoj4695】最假女选手 线段树区间最值操作
weixin_30835649的博客
01-25 144
题目描述 给定一个长度为 N 序列，编号从 1 到 N 。要求支持下面几种操作：1.给一个区间[L,R] 加上一个数x2.把一个区间[L,R] 里小于x 的数变成x3.把一个区间[L,R] 里大于x 的数变成x4.求区间[L,R] 的和5.求区间[L,R] 的最大值6.求区间[L,R] 的最小值 输入 第一行一个整数 N 表示序列长度。 第二行 N 个整数 Ai 表示初始序...
bzoj4695 最假女选手（势能线段树/吉司机线段树）题解
weixin_30412577的博客
09-11 186
题意： 已知\(n\)个数字，进行以下操作： \(1.\)给一个区间\([L,R]\) 加上一个数\(x\) \(2.\)把一个区间\([L,R]\) 里小于\(x\) 的数变成\(x\) \(3.\)把一个区间\([L,R]\) 里大于\(x\) 的数变成\(x\) \(4.\)求区间\([L,R]\)的和 \(5.\)求区间\([L,R]\)的最大值 \(6.\)求区间\([L,R...
Node.js-ZOJCH是BZOJ题库的离线版
08-09
ZOJCH是BZOJ题库的离线版
wangjunrui666#bzoj-problem##5165. 树上倍增1
07-25
您需要写一个树上倍增算法，以实现如下操作：A x 新建一个节点，将它作为x节点的儿子，编号为当前节点总数+1。保证询问不超过1000次输出格式对于每一个Q操作，
wangjunrui666#bzoj-problem##3040. 最短路(road)1
07-25
N个点，M条边的有向图，求点1到点N的最短路（保证存在）。2.重复以下过程T次：则有一条从a到b的，长度为1e8-100*a的有向边。后M-T条边采用读入方式：
CTSC 2011 无穷图的桥(BZOJ 2307) 题解.ppt
03-17
CTSC 2011 无穷图的桥(BZOJ 2307) 题解.ppt
【BZOJ4695】最假女选手 jls线段树
tlyzxc的博客
09-10 216
传送⻔ 题意 分析 首先考虑如果将单调修改转化为区间修改 在进行操作二的时候，如果区间内的最小值小于xxx，区间内的严格次小值大于等于xxx，那么我们可以去对这个区间进行整体修改 所以，我们需要在线段树中维护区间最大值，最大值出现的次数，最小值，最小值出现的次数，并且维护区间和和懒标记 代码 #pragma GCC optimize(3) #include <bits/stdc++.h> #define debug(x) cout<<#x<<":"<<x&l
BZOJ 4695 最假女选手 线段树
daxian3723的博客
12-28 102
题意： 　　给定一个长度为 N序列，编号从1 到 N。要求支持下面几种操作： 　　1.给一个区间[L,R] 加上一个数x 　　2.把一个区间[L,R] 里小于x 的数变成x 　　3.把一个区间[L,R] 里大于x 的数变成x 　　4.求区间[L,R] 的和 　　5.求区间[L,R] 的最大值 　　6.求区间[L,R] 的最小值 分析： 　　你听说过Segme...
[BZOJ]4695: 最假女选手
weixin_30311605的博客
01-29 141
题解: 看到这个题想的直接最大最小 次大次小 已经最大最小值出现的次数 和 求和 第一次做的时候 维护了最大值和最小值改变的下传标记 但是没有处理好与区间加标记的先后顺序 后来看了别人的题解 发现不用维护最值下传标记 因为可以通过判断其儿子的最值是否发生改变 然后用父亲的最值去更新即可 然后就只用维护区间加的标记 就行了 #include <algorithm> #...
bzoj4695: 最假女选手 （分块纪念）
OZY的博客
09-27 993
分块纪念
bzoj4695: 最假女选手 //吉利线段树
蒟蒻名曰Starria
03-04 1233
bzoj4695: 最假女选手 给出长为N(≤5e5)的序列，要求支持区间加、区间取min/max、区间求和、区间求min/max。 我 好久好久以前 就想学这个科技… O(nlog^2n)的SegmentTreeBeats!
【BZOJ4695】最假女选手
cz_xuyixuan的博客
01-19 1570
【题目链接】点击打开链接【思路要点】题目中提到的操作均为区间操作，考虑使用线段树。2号操作和3号操作并非线段树的一般操作，无法直接支持标记合并。考虑一个被2号操作定位的区间，记区间最小值为\(Min\)，严格次小值为\(Nin\)，对该区间实行操作数为\(Val\)的2号操作。若\(Min≥Val\)，显然这个操作可以直接忽略。若\(MinVal\)，我们可以将这个操作看作是对区间中最小值的整体加
2018.07.27 bzoj4695: 最假女选手（线段树）
weixin_30621711的博客
07-27 131
传送门 线段树好题 支持区间加，区间取minmin和maxmax。 维护区间和，区间最大值，区间最小值。 这题可以类比另外一道线段树 维护区间最大，次大，最小，次小，和。 每次修改的时候考虑对每个量产生的影响，然后用最大最小值配合次大次小值剪枝就行了。 注意这题卡空间。 代码： #include<bits/stdc++.h...
BZOJ 4695 最假女选手
Canopus
05-16 380
题目链接 https://www.lydsy.com/JudgeOnline/problem.php?id=4695 思路 恶心题……思路请见2016年国家候选队论文《区间最值操作与历史最值问题——吉如一》 代码 #include &lt;cstdio&gt; #include &lt;algorithm&gt; const int maxn=500000; const i...
BZOJ4695: 最假女选手
Don't fake it till you made it
02-17 917
我好像被卡空间了啊？ 惨啊.. 代码好丑啊QAQ 考虑更新 类似VEB Tree的记录当前最大值 不过这样子还是不容易更新最小值的 于是记录一个次大值 和最大值个数便于更新 对于最大值用类似方法维护#include<cstdio> #include<iostream> #include<cstring> #include<cmath> using namespace std; char
bzoj 1040 zjoi2008 骑士 树形dp
最新发布
08-08
我们可以使用树形dp来解决这个问题，具体来说，我们可以将这个图看作是一棵树，每个点的父节点是它的前驱或者后继，然后我们从根节点开始，依次向下遍历，对于每个节点，我们可以考虑它的两个儿子，如果它的两个儿子...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值