uestc1324 卿学姐与公主 线段树或分块入门

卿学姐与公主

链接：卿学姐与公主

某日，百无聊赖的卿学姐打开了某11区的某魔幻游戏

在这个魔幻的游戏里，生活着一个美丽的公主，但现在公主被关押在了魔王的城堡中。

英勇的卿学姐拔出利刃冲向了拯救公主的道路。

走过了荒野，翻越了高山，跨过了大洋，卿学姐来到了魔王的第一道城关。

在这个城关面前的是魔王的精锐部队，这些士兵成一字排开。

卿学姐的武器每次只能攻击一个士兵，并造成一定伤害，卿学姐想知道某时刻从LL到RR这个区间内，从开始到现在累计受伤最严重的士兵受到的伤害。

最开始每个士兵的受到的伤害都是0

Standard Input

第一行两个整数N,Q表示总共有NN个士兵编号从1到N，和Q个操作。

接下来Q行，每行三个整数，首先输入一个t，如果t是1，那么输入p,x表示卿学姐攻击了p这个位置的士兵，并造成了x的伤害。如果t是2，那么输入L,R表示卿学姐想知道现在[L,R]闭区间内，受伤最严重的士兵受到的伤害。

1≤N≤100000

1≤Q≤100000

1≤p≤N

1≤x≤100000

1≤L≤R≤N

Standard Output

对于每个询问，回答相应的值

Samples

Input

5 4
2 1 2
1 2 4
1 3 5
2 3 3

Output

0
5
Note
注意可能会爆int哦

分析：

线段树或者分块入门题，维护最值直接写就行了(最近在学分块)。唯一要注意的是可能爆int。
下面是两种代码：

线段树代码：

#include<iostream>
#include<cstdio>
typedef long long ll;
const int inf=0x3f3f3f3f;
const int inn=0x80808080;
using namespace std;
const int maxm=1e5+5;
struct Node{
    int l,r;
    ll sum;
};
Node tree[maxm*4];
int n,q;
void pushup(int node){
    tree[node].sum=max(tree[node*2].sum,tree[node*2+1].sum);
}
void build(int l,int r,int node){
    tree[node].l=l;
    tree[node].r=r;
    tree[node].sum=0;
    if(l==r){
        return ;
    }
    int mid=(l+r)/2;
    build(l,mid,node*2);
    build(mid+1,r,node*2+1);
}
void update(int x,int val,int node){
    int l=tree[node].l;
    int r=tree[node].r;
    if(l==r){
        tree[node].sum+=val;
        return ;
    }
    int mid=(l+r)/2;
    if(x<=mid){
        update(x,val,node*2);
    }else{
        update(x,val,node*2+1);
    }
    pushup(node);
}
long long query(int st,int ed,int node){
    int l=tree[node].l;
    int r=tree[node].r;
    if(st<=l&&ed>=r){
        return tree[node].sum;
    }
    int mid=(l+r)/2;
    if(ed<=mid){
        return query(st,ed,node*2);
    }else if(st>=mid+1){
        return query(st,ed,node*2+1);
    }else{
        return max(query(st,mid,node*2),query(mid+1,ed,node*2+1));
    }
}
int main(){
    while(scanf("%d%d",&n,&q)!=EOF){//这题好像是单案例
        build(1,n,1);
        while(q--){
            int d,a,b;
            scanf("%d%d%d",&d,&a,&b);
            if(d==1){
                update(a,b,1);
            }else{
                printf("%I64d\n",query(a,b,1));
            }
        }
    }
    return 0;
}

分块代码:

#include<iostream>
#include<cstdio>
#include<cmath>
typedef long long ll;
const int inf=0x3f3f3f3f;
const int inn=0x80808080;
using namespace std;
const int maxm=1e5+5;
int l[maxm],r[maxm];
int belong[maxm];
ll Max[maxm],a[maxm];
int block,num;
int n,q;
void build(){
    block=sqrt(n);
    num=n/block;
    if(n%block){
        num++;
    }
    for(int i=1;i<=num;i++){
        l[i]=(i-1)*block+1;
        r[i]=i*block;
    }
    r[num]=n;
    for(int i=1;i<=n;i++){
        belong[i]=(i-1)/block+1;
    }
    for(int i=1;i<=num;i++){//这题好像是单案例所以这段初始化可以不用加。
        Max[i]=0;
        for(int j=l[i];j<=r[i];j++){
            a[j]=0;
        }
    }
}
void update(int x,int val){
    a[x]+=val;
    Max[belong[x]]=max(Max[belong[x]],a[x]);
}
long long ask(int x,int y){
    long long ans=0;
    if(belong[x]==belong[y]){//如果在同一块直接遍历
        for(int i=x;i<=y;i++){
            ans=max(ans,a[i]);
        }
        return ans;
    }
    for(int i=x;i<=r[belong[x]];i++){//遍历x所在块
        ans=max(ans,a[i]);
    }
    for(int i=belong[x]+1;i<belong[y];i++){//遍历x和y之间的块
        ans=max(ans,Max[i]);
    }
    for(int i=l[belong[y]];i<=y;i++){//遍历y所在块
        ans=max(ans,a[i]);
    }
    return ans;
}
int main(){
    while(scanf("%d%d",&n,&q)!=EOF){//这题好像是单案例
        build();
        while(q--){
            int d,a,b;
            scanf("%d%d%d",&d,&a,&b);
            if(d==1){
                update(a,b);
            }else{
                printf("%I64d\n",ask(a,b));
            }
        }
    }
    return 0;
}