【bzoj4826】影魔(线段树+单调栈+扫描线)

最新推荐文章于 2019-07-10 20:45:01 发布
最新推荐文章于 2019-07-10 20:45:01 发布
阅读量428 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： 线段树 单调栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Etta19/article/details/74838648
本文介绍了一种计算影魔灵魂战斗力的方法，通过分析灵魂间的战斗力关系，利用数据结构实现了高效查询，具体涉及到了线段树和树状数组的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Description

    影魔,奈文摩尔,据说有着一个诗人的灵魂。事实上,他吞噬的诗人灵魂早已成千上万。千百年来,他收集了各式各样的灵魂,包括诗人、牧师、帝王、乞丐、奴隶、罪人,当然,还有英雄。每一个灵魂,都有着自己的战斗力,而影魔,靠这些战斗力提升自己的攻击。奈文摩尔有 n 个灵魂,他们在影魔宽广的体内可以排成一排,从左至右标号 1 到 n。
    第 i个灵魂的战斗力为 k[i],灵魂们以点对的形式为影魔提供攻击力,对于灵魂对 i,j ( i < j ) 来说,若不存在 k[s] ( i < s < j ) 大于 k[i]或者 k[j],则会为影魔提供 p1 的攻击力(可理解为:当 j=i+1 时,因为不存在满足 i < s < j 的 s,从而 k[s]不存在,这时提供 p1 的攻击力;当 j>i+1 时,若max{k[s]| i < s < j}< =min{k[i],k[j]} , 则 提 供 p1 的 攻击 力 ); 另 一 种 情 况 , 令 c 为k[i+1],k[i+2],k[i+3]……k[j-1]的最大值,若 c 满足:k[i] < c < k[j],或者 k[j] < c< k[i],则会为影魔提供 p2 的攻击力,当这样的 c 不存在时,自然不会提供这 p2 的攻击力;其他情况的点对,均不会为影魔提供攻击力。影魔的挚友噬魂鬼在一天造访影魔体内时被这些灵魂吸引住了,他想知道,对于任意一段区间[a,b],1< =a< b< =n,位于这些区间中的灵魂对会为影魔提供多少攻击力,即考虑 所有满足a< =i< j< =b 的灵魂对 i,j 提供的攻击力之和。顺带一提,灵魂的战斗力组成一个 1 到 n 的列:k[1],k[2],…,k[n]。

Input

    第一行 n,m,p1,p2
    第二行 n 个数:k[1],k[2],…,k[n]
    接下来 m 行,每行两个数 a,b,表示询问区间[a,b]中的灵魂对会为影魔提供多少攻击力。
    1 <= n,m <= 200000;1 <= p1,p2 <= 1000

Output

    共输出 m 行,每行一个答案,依次对应 m 个询问。

Sample Input

10 5 2 3 
7 9 5 1 3 10 6 8 2 4 
1 7 
1 9 
1 3 
5 9
1 5

Sample Output

30
39
4
13
16

I think

    首先我们发现k[i]是一个排列，也就是该正项数列中没有重复元素。我们找出对于每一个k[i]，

L[i]=Max{j,j∈[1,i−1]且k[j]>k[i]}
R[i]=Min{j,j∈[i+1,n]且k[j]>k[i]}

    那么
    1)区间[L[i],r[i]] 有贡献p1
    2)区间[L[i],j],j∈[i+1,R[i]-1] 有贡献p2
    3)区间[j,R[i]],j∈[L[i]+1,i-1] 有贡献p2
    于是我们可以把区间看作一个xy坐标轴上的点，对于每一个被询问区间Q(a,b)，其答案是以(a,b)与(n,1)为对角线的矩形内的点权和。一段连续的点可以用扫描线+线段树更新，一边更新一边更新包含该段区间的询问对应答案。扫描线沿xy轴分别扫一遍就ok。
     代码中，由于有p1贡献的点和横坐标一定为L[i]的点同时存储在LX中，所以空间开两倍。
    用树状数组实现更快，代码也更简洁。

Code

#include<vector>
#include<cstdio>
#include<algorithm>
#define s second
using namespace std;

#define int long long 
const int sm = 2e5+10;
const int sn = sm << 1;

typedef long long ll;
typedef pair<int,int> pii;
int n,m,p1,p2,t1,t2;
int k[sm],L[sm],R[sm];//注意k为一个排列元素不重复
ll ans[sm],val[sm<<2],mk[sm<<2];
vector<int> xx[sm],yy[sm];//存询问
vector<int> MX[sm],MY[sm];
pii st[sm],t;

struct line {
    int a,b1,b2,c;
}LX[sm << 1],LY[sm];
struct query {
    int l,r,id;
}Q[sm];

char ch;
void read(int &x) {
    x=0,ch=getchar();
    while(ch>'9'||ch<'0')ch=getchar();
    while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
}
void calc() { 
//利用单调栈求L[i],R[i]
//L[i]=max{k[j]},j<i&&k[j]>k[i]
//R[i]=min{k[j]},j>i&&k[j]>k[i] 
    int tp;
    st[tp=1] = make_pair(k[1],1);
    for(int i=2;i<=n;++i) {
        t=make_pair(k[i],i);
        while(tp&&st[tp]<t) --tp;
        if(!tp) L[i]=0;
        else L[i]=st[tp].s;
        st[++tp]=t; 
    } 
    R[n]=n+1;
    st[tp=1] = make_pair(k[n],n);
    for(int i=n-1;i>=1;--i) {
        t=make_pair(k[i],i);
        while(tp&&st[tp]<t) --tp;
        if(!tp) R[i]=n+1;
        else R[i]=st[tp].s;
        st[++tp]=t;
    }
}

void pushdown(int k,int l,int r) {
    int ls=k<<1,rs=k<<1|1,m=(l+r)>>1;
    mk[rs]+=mk[k],val[rs]+=mk[k]*(r-m);
    mk[ls]+=mk[k],val[ls]+=mk[k]*(m-l+1);
    mk[k]=0;
}

void add(int k,int l,int r,line L) {
    if(L.b1<=l&&r<=L.b2) {
        val[k]+=L.c*(r-l+1); //printf("*%d %d %d\n",L.c,l,r);
        mk[k]+=L.c;return;
    }
    if(l==r)return;
    if(mk[k])pushdown(k,l,r);
    int m=(l+r)>>1;
    if(L.b1<=m) add(k<<1,l,m,L);
    if(L.b2> m) add(k<<1|1,m+1,r,L);
    val[k]=val[k<<1]+val[k<<1|1];
}

int query(int k,int l,int r,int ll,int rr) {
    if( l > rr || r < ll )return 0;
    if(ll<=l&&r<=rr) return val[k];
    if(mk[k]) pushdown(k,l,r);
    int m=(l+r)>>1,tmp=0;
    if(ll<=m) tmp+=query(k<<1,l,m,ll,rr);
    if(rr> m) tmp+=query(k<<1|1,m+1,r,ll,rr);
    return tmp;
}

void build(int k,int l,int r) {
    val[k]=mk[k]=0;
    if(l==r)return;
    int m=(l+r)>>1;
    build(k<<1,l,m);
    build(k<<1|1,m+1,r);
}

void work() {
    int g;
    for(int i=n;i>=1;--i) { //扫描线沿x轴方向由右至左扫
        for(int j=0;j<MX[i].size();++j) 
            g=MX[i][j],add(1,1,n,LX[g]);
        for(int j=0;j<xx[i].size();++j) 
            g=xx[i][j],ans[g]+=query(1,1,n,1,Q[g].r);// ind=1 取[1,r]
    }
    build(1,1,n);
    for(int i=1;i<=n;++i) {
        for(int j=0;j<MY[i].size();++j) 
            g=MY[i][j],add(1,1,n,LY[g]);
        for(int j=0;j<yy[i].size();++j)
            g=yy[i][j],ans[g]+=query(1,1,n,Q[g].l,n);// ind=0 取[l,n]
    }
}
main() {
    read(n),read(m);
    read(p1),read(p2);
    for(int i=1;i<=n;++i) read(k[i]);
    calc();
    for(int i=1,x,y;i<=m;++i) {
        read(x),read(y);
        Q[i].l=x,Q[i].r=y,Q[i].id=i;
        xx[x].push_back(i),yy[y].push_back(i);
        //即将询问i加入以x为询问左端的询问序列xx[x]中
    }
    for(int i=1;i<=n;++i) {//存贡献值为p1的点
        if(L[i]!=0&&R[i]!=n+1) {
            LX[++t1].a=L[i], LX[t1].c=p1;
            LX[t1].b1=LX[t1].b2=R[i],MX[L[i]].push_back(t1);//不要漏掉加入MX
        }
        if(L[i]!=0||R[i]!=n+1) {
            if(i+1<=R[i]-1) {//将贡献值为p2的点分别以平行与x|y轴线段的形式存储
                LX[++t1].a=L[i], LX[t1].b1=i+1, LX[t1].b2=R[i]-1;
                LX[t1].c=p2, MX[L[i]].push_back(t1); //将t1存入以L[i]为a的序列中
            }
            if(L[i]+1<=i-1) {
                LY[++t2].a=R[i], LY[t2].b1=L[i]+1, LY[t2].b2=i-1;
                LY[t2].c=p2, MY[R[i]].push_back(t2);
            }
        }
    }
    work();
    for(int i=1;i<=m;++i)
        printf("%lld\n",ans[i]+(Q[i].r-Q[i].l)*p1);
    return 0;
}

再贴一份更简洁的树状数组代码……

#include<vector>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define s second
#define lowbit(x) x&(-x)
using namespace std;

const int sm = 2e5+10;
const int sn = sm << 1;

typedef long long ll;
typedef pair<int,int> pii;
int n,m,p1,p2,t1,t2;
int k[sm],L[sm],R[sm];//注意k为一个排列元素不重复
ll sum,ans[sm],b[sm],c[sm];
vector<int> xx[sm],yy[sm];//存询问
vector<int> MX[sm],MY[sm];
pii st[sm],t;

struct line {
    int a,b1,b2,c;
}LX[sm<<1],LY[sm];
struct query {
    int l,r,id;
}Q[sm];

char ch;
void read(int &x) {
    x=0,ch=getchar();
    while(ch>'9'||ch<'0')ch=getchar();
    while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
}
void calc() { 
//利用单调栈求L[i],R[i]
//L[i]=max{k[j]},j<i&&k[j]>k[i]
//R[i]=min{k[j]},j>i&&k[j]>k[i] 
    int tp;
    st[tp=1] = make_pair(k[1],1);
    for(int i=2;i<=n;++i) {
        t=make_pair(k[i],i);
        while(tp&&st[tp]<t) --tp;
        if(!tp) L[i]=0;
        else L[i]=st[tp].s;
        st[++tp]=t; 
    } 
    R[n]=n+1;
    st[tp=1] = make_pair(k[n],n);
    for(int i=n-1;i>=1;--i) {
        t=make_pair(k[i],i);
        while(tp&&st[tp]<t) --tp;
        if(!tp) R[i]=n+1;
        else R[i]=st[tp].s;
        st[++tp]=t;
    }
}
void add(int x,int y) {
    for(int i=x;i<=n;i+=lowbit(i))
        b[i]+=y,c[i]+=x*y;
} 
ll Query(int x) {
    sum=0;
    for(int i=x;i;i-=lowbit(i))
        sum+=(x+1)*b[i]-c[i];
    return sum;
}
void work() {
    int g;
    line x;
    query y;
    for(int i=n;i>=1;--i) { //扫描线沿x轴方向由右至左扫
        for(int j=0;j<MX[i].size();++j) {
            g=MX[i][j]; x=LX[g];
            add(x.b1,x.c),add(x.b2+1,-x.c);//add(1,1,n,LX[g]);
        }
        for(int j=0;j<xx[i].size();++j) { 
            g=xx[i][j]; y=Q[g];
            ans[g]+=Query(y.r)-Query(y.l-1);//query(1,1,n,1,Q[g].r);// ind=1 取[1,r]
        }
    }
    memset(b,0,sizeof(b));
    memset(c,0,sizeof(c));
    for(int i=1;i<=n;++i) {
        for(int j=0;j<MY[i].size();++j) {
            g=MY[i][j]; x=LY[g];
            add(x.b1,x.c),add(x.b2+1,-x.c);
        }
        for(int j=0;j<yy[i].size();++j) {
            g=yy[i][j]; y=Q[g];
            ans[g]+=Query(y.r)-Query(y.l-1);// ind=0 取[l,n]
        }
    }
}
int main() {
    read(n),read(m);
    read(p1),read(p2);
    for(int i=1;i<=n;++i) read(k[i]);
    calc();
    for(int i=1,x,y;i<=m;++i) {
        read(x),read(y);
        Q[i].l=x,Q[i].r=y,Q[i].id=i;
        xx[x].push_back(i),yy[y].push_back(i);
        //即将询问i加入以x为询问左端的询问序列xx[x]中
    }
    for(int i=1;i<=n;++i) {//存贡献值为p1的点
        if(L[i]!=0&&R[i]!=n+1) {
            LX[++t1].a=L[i], LX[t1].c=p1;
            LX[t1].b1=LX[t1].b2=R[i],MX[L[i]].push_back(t1);//不要漏掉加入MX
        }
        if(L[i]!=0||R[i]!=n+1) {
            if(i+1<=R[i]-1) {//将贡献值为p2的点分别以平行与x|y轴线段的形式存储
                LX[++t1].a=L[i], LX[t1].b1=i+1, LX[t1].b2=R[i]-1;
                LX[t1].c=p2, MX[L[i]].push_back(t1); //将t1存入以L[i]为a的序列中
            }
            if(L[i]+1<=i-1) {
                LY[++t2].a=R[i], LY[t2].b1=L[i]+1, LY[t2].b2=i-1;
                LY[t2].c=p2, MY[R[i]].push_back(t2);
            }
        }
    }
    work();
    for(int i=1;i<=m;++i)
        printf("%lld\n",ans[i]+(Q[i].r-Q[i].l)*p1);
    return 0;
}
BZOJ4709 浅谈单调栈
BerryKanry的博客
07-01 463
世界真的很大 单调栈这东西其实挺玄学的。。 看起来很好懂其实应用还是很广的，认真想起来还是很烧脑。 以题为例 descriptionFlute 很喜欢柠檬。它准备了一串用树枝串起来的贝壳，打算用一种魔法把贝壳变成柠檬。贝壳一共有 N (1 ≤ N ≤ 100,000) 只，按顺序串在树枝上。为了方便，我们从左到右给贝壳编号 1..N。每只贝壳的大小不一定相同， 贝壳 i 的大小为 si(1
Bzoj 4422: [Cerc2015]Cow Confinement(线段树+扫描线）
ShallWe 's Blog
08-10 1284
bzoj 4422: [Cerc2015]Cow Confinement 题目题目链接 Description一个10^6行10^6列的网格图，上面有一些牛、花和一些矩形围栏，围栏在格子的边界上，牛和花在格子里，牛只能向下或向右走，牛也不能穿过围栏和地图边界，求每头牛它能到达的花的数量。注意栅栏不会相交 Input第一行一个数f表示矩形围栏的数量
刷题总结——影魔（HNOI2017 BZOJ4826 线段树+扫描线）
banzhangzhi8819的博客
09-26 161
题目： Description 影魔,奈文摩尔,据说有着一个诗人的灵魂。事实上,他吞噬的诗人灵魂早已成千上万。千百年来,他收集了各式各样 的灵魂,包括诗人、牧师、帝王、乞丐、奴隶、罪人,当然,还有英雄。每一个灵魂,都有着自己的战斗力,而影魔,靠 这些战斗力提升自己的攻击。奈文摩尔有 n 个灵魂,他们在影魔宽广的体内可以排成一排,从左至右标号 1 到 n。 第 i个灵魂的战斗...
BZOJ4826: [Hnoi2017]影魔
wxh010910
04-23 444
Description 影魔,奈文摩尔,据说有着一个诗人的灵魂。事实上,他吞噬的诗人灵魂早已成千上万。千百年来,他收集了各式各样 的灵魂,包括诗人、牧师、帝王、乞丐、奴隶、罪人,当然,还有英雄。每一个灵魂,都有着自己的战斗力,而影魔,靠 这些战斗力提升自己的攻击。奈文摩尔有 n 个灵魂,他们在影魔宽广的体内可以排成一排,从左至右标号 1 到 n。 第 i个灵魂的战斗力为 k[i],灵魂
BZOJ4826：[Hnoi2017]影魔 （单调栈+扫描线+线段树）
KsCla
11-27 907
题目传送门：http://www.lydsy.com/JudgeOnline/problem.php?id=4826题目分析：这题是我在今年4月份省赛前看到的，那个时候想了一下，发现不会做。7个月后的今天，我试图把这个坑填了，然而想了很久还是不会做，最后只好%了一波网上的题解，才发现自己智商低下，思维僵化QAQ。本题的主要思路是转化贡献。由于k是1~n的一个排列，所以如果L+1<<R，(L,R)中必
BZOJ4826 [Hnoi2017]影魔
neither_nor
04-17 2227
对每个点i，单调栈求出左边和右边第一个大于i的位置，记为l[i]和r[i] 那么(l[i],r[i])会产生p1的贡献 左端点为l[i]，右端点在[i+1,r-1]的点对都会产生p1的贡献 右端点为r[i]，左端点在[l+1,i-1]的点对都会产生p2的贡献 将点对看成平面上的点，横坐标左端点纵坐标右端点，上述贡献分别对应单点加和线段加 查询就是矩形求和 用主席树维护即可 #incl
【BZOJ 1645】[Usaco2007 Open] City Horizon 城市地平线（线段树+扫描线）
t14 的博客
06-24 233
题目 Description Farmer John has taken his cows on a trip to the city! As the sun sets, the cows gaze at the city horizon and observe the beautiful silhouettes formed by the rectangular buildings. The e...
[BZOJ2584][Wc2012]memory（扫描线+splay+线段树）
zyf2000
04-22 1377
题目描述传送门题目大意：在二维平面中有n个线段，线段互不相交，每一次一个操作将一个线段向四个方向之一移走（也就是平移到无穷远处），如果移动的过程中被其他线段所阻挡则移动是不合法的。求：最早的一次不合法移动；构造一种合法的移动序列将所有线段移走题解首先考虑第二问，实际上所有的线段都按照任意一个固定的方向移动就是可以直接都移走的，所以我们需要将线段编号。因为线段均不相交，所以对于任意两条线段的所有横坐标
【BZOJ4422】Cow Confinement【扫描线】【差分】【线段树】
ezoixx118的博客
07-10 590
题意 一个10610^6106行10610^6106列的网格图，上面有一些牛、花和一些矩形围栏，围栏在格子的边界上，牛和花在格子里，牛只能向下或向右走，不能穿过围栏和地图边界，求每头牛它能到达的花的数量。（栅栏不会相交） 题解 暴力 首先，可以想出一个很显然的dp，设dpi,jdp_{i,j}dpi,j​表示方格(i,j)(i,j)(i,j)能到达的花数。要分类讨论，前三种情况很简单，再次不赘述，...
[BZOJ3958][WF2011]Mummy Madness（二分+扫描线+线段树）
zyf2000
04-20 968
题目描述传送门题目大意：一个正方形的网格，你与木乃伊轮流移动（你走出第一步）。轮到你时，你可以移动到相邻的8个格子之一，或者站着不动。轮到木乃伊时，每个木乃伊会移动到其相邻的格子之一，使得他与你的欧几里得距离尽量小（假设你与木乃伊都站在格子的中心位置）。允许多个木乃伊同时占据同一个格子。 在每个单位时间内，你先做出移动，然后木乃伊做出移动。如果你与任何一个木乃伊站在同一位置，你会被抓住。当然，你试
[单调栈 扫描线] BZOJ 4826 [Hnoi2017]影魔
雯舞
04-20 929
先用单调栈找出比ii大的第一个数lil_i 和 rir_i 然后[i,i+1][i,i+1]有p1的贡献 [li,ri][l_i,r_i]有p1的贡献 [li,x] x∈[i+1,ri−1][l_i,x] \ x\in [i+1,r_i-1] 有p2的贡献 [x,ri] x∈[li+1,i−1][x,r_i] \ x\in [l_i+1,i-1] 有p2的贡献 放在平面上就是点和线段 矩形求
[HNOI 2017] bzoj4826 影魔 [单调栈+扫描线]
pocket_legend
03-12 239
Description: 提供p1p1p1的攻击力:i,ji,ji,j位置的数是区间[i,j][i,j][i,j]的最大值和次大值 提供p2p2p2的攻击力:i,ji,ji,j位置的数有一个是区间[i,j][i,j][i,j]的最大值，另一个不是次大值 Solution: 考虑枚举aiaia_i,并用单调栈求出左右第一个比aiaia_i大的位置li,rili,ril_i,r_i。 p...
【BZOJ4826】【HNOI2017】影魔（线段树）
დ♂Hany01's Blog Space♂ღ
03-04 251
Description click me Solution 参考了dyx的博客 %%% 用单调栈的方式处理出每个位置左右第一个比他大的数的位置 对于每对lef[i]和rig[i]都会做出p1的贡献 每个lef[i]会对i+1到rig[i]−1做出p2贡献 同理，每个rig[i]都会给lef[i]+1到i−1做出p2贡献 Source /*********...
bzoj4826 [Hnoi2017]影魔
老臣
04-19 1106
分析：直接贴题解了： 对每个点i，单调栈求出左边和右边第一个大于i的位置，记为l[i]和r[i] 那么(l[i],r[i])会产生p1的贡献 左端点为l[i]，右端点在[i+1,r-1]的点对都会产生p2的贡献（原来题解笔误了） 右端点为r[i]，左端点在[l+1,i-1]的点对都会产生p2的贡献 将点对看成平面上的点，横坐标左端点纵坐标右端点，上述贡献分别对应单点加（p1）和线段加（p2
【BZOJ4826】【HNOI2017】影魔
SunIsMe的博客
05-22 541
题目描述给定一个长度n≤2×105n\leq2\times10^5的序列a，对于点对(i,j)(i,j)若不存在i<k<ji<k<j使得a[i]<a[k]或a[j]<a[k]a[i]<a[k]或a[j]<a[k]，则点对向答案贡献p1p_1，若存在i<k<ji<k<j使得a[i]<a[k]且a[k]<a[j]a[i]<a[k]且a[k]<a[j]，或a[i]>a[k]且a[k]>a[j]a[i]>a
BZOJ4826: [Hnoi2017]影魔（扫描线+树状数组）
DZYO的博客
09-21 543
传送门题意： 有n个点，横纵坐标都是1−n1-n的排列，每次询问[l,r][l,r]，求在[l,r][l,r]中分别满足一下条件的点对(i,j)(i,j)： (定义max(l,r)max(l,r)为横坐标ll到rr中纵坐标的最大值) 1.y[i]>max(l,r)且y[j]>max(l,r)y[i]\gt max(l,r)且y[j]\gt max(l,r). 2.y[i]>max(l,r)>
bzoj4826 [Hnoi2017]影魔（单调栈+主席树）
Icefox的博客
06-16 354
我们先单调栈求出每一个数左边/右边第一个大于他的数的位置L,R 那么以a[i]为最大数的贡献是: 左端点L[i],右端点R[i],贡献p1 左端点L[i]+1~i-1,右端点R[i]，贡献p2 左端点L[i],右端点i+1~R[i]-1，贡献p2 我们如果把左右端点当做坐标的话，投射到二维平面上，那么我们每次求的就是一个矩形和。有一些单点加，某一维上的线段加。因此可以直接用主席树解决O(...
[bzoj4826][HNOI2017]影魔
不来也不去的一只失忆蝴蝶
04-19 1415
题目描述影魔,奈文摩尔,据说有着一个诗人的灵魂。事实上,他吞噬的诗人灵魂早已成千上万。千百年来,他收集了各式各样 的灵魂,包括诗人、牧师、帝王、乞丐、奴隶、罪人,当然,还有英雄。每一个灵魂,都有着自己的战斗力,而影魔,靠 这些战斗力提升自己的攻击。奈文摩尔有 n 个灵魂,他们在影魔宽广的体内可以排成一排,从左至右标号 1 到 n。 第 i个灵魂的战斗力为 k[i],灵魂们以点对的形式为影魔提供
【bzoj4826】[Hnoi2017]影魔
Joky_2002的博客
04-15 272
4826: [Hnoi2017]影魔Time Limit: 20 Sec  Memory Limit: 512 MBSubmit: 798  Solved: 464[Submit][Status][Discuss]Description影魔,奈文摩尔,据说有着一个诗人的灵魂。事实上,他吞噬的诗人灵魂早已成千上万。千百年来,他收集了各式各样的灵魂,包括诗人、牧师、帝王、乞丐、奴隶、罪人,当然,还有英...
等差数列与数据结构——线段树、树状数组解析
"本资源是一份关于BZOJ算术天才⑨与等差数列问题的线段树和树状数组应用的课件，主要针对信息竞赛和OI选手，涵盖了线段树和树状数组的基本概念、优势及在解决实际问题中的应用策略。标签涉及信息竞赛、OI、线段树、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值