线段树专题

搞完了线段树专题

拿几道还比较有意义的题来写一下博客吧

还是先%棒神为好

① 小白逛公园 bzoj 1756

题目大意：

一个序列 支持单点修改和区间内连续子段最大值

思路：

对于线段树上每一段维护四个东西

每一段从左起的最大值 从右起的最大值 这一段的sum 这一段的答案

然后合并的时候可以很容易的合并 此时在query的时候return 一个节点比较方便

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<queue>
#include<vector>
#include<map>
#define inf 2139062143
#define ll long long
#define MAXN 500100
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)) {if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch)) x=x*10+ch-'0',ch=getchar();
    return x*f;
}
struct data 
{
    int mx,lm,rm,sum,l,r;
    //void PRINT() {cout<<l<<" "<<r<<" "<<mx<<" "<<lm<<" "<<rm<<" "<<sum<<endl;}
}tr[MAXN<<2];
int n,T,a[MAXN];
void upd(int k)
{
    tr[k].sum=tr[k<<1].sum+tr[k<<1|1].sum;
    tr[k].lm=max(tr[k<<1].lm,tr[k<<1|1].lm+tr[k<<1].sum);
    tr[k].rm=max(tr[k<<1|1].rm,tr[k<<1].rm+tr[k<<1|1].sum);
    tr[k].mx=max(tr[k<<1].rm+tr[k<<1|1].lm,max(tr[k<<1|1].mx,tr[k<<1].mx));
    //tr[k].PRINT();
}
void build(int k,int l,int r)
{
    tr[k].l=l,tr[k].r=r;
    if(l==r) {tr[k].mx=tr[k].lm=tr[k].rm=tr[k].sum=a[l];return ;}
    int mid=(l+r)>>1;
    build(k<<1,l,mid);build(k<<1|1,mid+1,r);
    upd(k);
}
void mdf(int k,int x,int w)
{
    int l=tr[k].l,r=tr[k].r;
    if(l==r) {tr[k].mx=tr[k].lm=tr[k].rm=tr[k].sum=w;return ;}
    int mid=(l+r)>>1;
    if(mid>=x) mdf(k<<1,x,w);
    else mdf(k<<1|1,x,w);
    //cout<<"MODIFY: "<<k<<" "<<x<<" "<<w<<endl;
    upd(k);
}
data query(int k,int a,int b)
{
    int l=tr[k].l,r=tr[k].r;
    if(l==a&&r==b) return tr[k];
    int mid=(l+r)>>1;
    if(mid>=b) return query(k<<1,a,b);
    else if(mid<a) return query(k<<1|1,a,b);
    else
    {
        //cout<<"Q: "<<k<<" "<<a<<" "<<b<<endl;
        data x=query(k<<1,a,mid),y=query(k<<1|1,mid+1,b),res;
        //x.PRINT();y.PRINT();
        res.lm=max(x.lm,y.lm+x.sum);
        res.rm=max(y.rm,x.rm+y.sum);
        res.mx=max(x.rm+y.lm,max(y.mx,x.mx));
        //res.PRINT();
        return res;
    }
}
int main()
{
    n=read(),T=read();int x,y,z;data res;
    for(int i=1;i<=n;i++) a[i]=read();
    build(1,1,n);
    while(T--)
    {
        x=read(),y=read(),z=read();
        if(x==1) printf("%d
",query(1,min(y,z),max(y,z)).mx);
        else mdf(1,y,z);
    }
}

② MooFest poj 1990

题目大意：

现在有n头奶牛，第i头奶牛的听力阈值为v(i),即如果其他奶牛想让这只奶牛听到它的声音，那么至少得发出v(i)乘上它们之间距离这么大的音量

所以如果第i头奶牛和第j头奶牛交谈，那么发出的音量大小至少是它们之间的距离乘上它们两个阈值中的最大值，即max(v(i),v(j))

现在这n头奶牛站在了一条直线上，每头奶牛都站在唯一的坐标上

并且每对奶牛交谈都尽可能降低音量。那么请你计算出这n*(n-1)/2对奶牛交谈产生的最小总音量大小

思路：

使用树状数组就可以很方便的维护

先将奶牛按照v值排序 这样它与排序后前面的奶牛说话使用的是它的v值

然后我们需要求出它前面所有奶牛与它的距离之和

可以分成两种情况 位置在左边或者右边

然后我们开两个树状数组分别维护哪个位置有奶牛来求出它左边和右边各有多少个奶牛

另一个维护距离之和 这样就可以分别知道它左边和右边奶牛的距离之和 然后推一个小学数学公式即可

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<queue>
#include<vector>
#include<map>
#define inf 2139062143
#define ll long long
#define MAXN 20100
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)) {if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch)) x=x*10+ch-'0',ch=getchar();
    return x*f;
}
int n;
ll ans;
struct data {int pos,val;}g[MAXN];
bool cmp(data x,data y) {return x.val<y.val;}
struct array
{
    ll c[MAXN];
    inline int lowbit(int x) {return x&(-x);}
    void add(int x,int val) {for(int i=x;i<=MAXN;i+=lowbit(i)) c[i]+=val;}
    ll sum(int x) {ll res=0;for(int i=x;i;i-=lowbit(i)) res+=c[i];return res;}
}a,b;
int main()
{
    n=read();ll tot=0,x,y;
    for(int i=1;i<=n;i++) g[i].val=read(),g[i].pos=read();
    sort(g+1,g+n+1,cmp);
    for(int i=1;i<=n;i++)
    {
        x=a.sum(g[i].pos-1),y=b.sum(g[i].pos-1);
        ans+=g[i].val*(x*g[i].pos-y-(i-x-1)*g[i].pos+(tot-b.sum(g[i].pos-1)));
        //cout<<g[i].val<<"*("<<x<<"*"<<g[i].pos<<"-"<<y<<"-"<<(i-x-1)<<"*"<<g[i].pos<<"+("<<tot<<"-"<<b.sum(g[i].pos-1)<<"))"<<endl<<ans<<endl;
        tot+=g[i].pos;
        a.add(g[i].pos,1);b.add(g[i].pos,g[i].pos);
    }
    printf("%lld",ans);
}

③ 遭遇战 vijos 1404 

题目大意：

一个大区间1-n

有一些区间l-r可以覆盖并有一些代价

求出最小代价覆盖s-t区间

思路：

可以建图来跑最短路

对于每个l r 从l向r+1连一条边 然后每个i向i-1连一条边

最后跑s-t+1的最短路即可（dij比spfa快到不知道哪里去了

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<queue>
#include<vector>
#include<map>
#define inf 2139062143
#define ll long long
#define MAXN 90101
#define P pair<int,int>
#define mp(a,b) make_pair(a,b)
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)) {if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch)) x=x*10+ch-'0',ch=getchar();
    return x*f;
}
int s,t,dis[MAXN],n;
int fst[MAXN],nxt[MAXN<<1],to[MAXN<<1],val[MAXN<<1],cnt;
void add(int u,int v,int w) {nxt[++cnt]=fst[u],fst[u]=cnt,to[cnt]=v,val[cnt]=w;}
int dij()
{
    priority_queue<P,vector<P>,greater<P> > q;
    memset(dis,127,sizeof(dis));
    dis[s]=0;q.push(mp(0,s));
    while(!q.empty())
    {
        int k=q.top().second;q.pop();
        for(int i=fst[k];i;i=nxt[i])
            if(dis[to[i]]>dis[k]+val[i]) {dis[to[i]]=dis[k]+val[i];q.push(mp(dis[to[i]],to[i]));}
    }
    return dis[t+1]==inf?-1:dis[t+1];
}
int main()
{
    int a,b,c;
    n=read(),s=read(),t=read();
    while(n--) {a=max(read(),s),b=min(read()+1,t+1),c=read();add(a,b,c);add(b,a,c);}
    for(int i=s+1;i<=t+1;i++) add(i,i-1,0);
    printf("%d",dij());
}

④ Mayor's posters poj 2528

题目大意：

向一些区间上贴海报

问贴完之后有多少个海报露出来

思路：

本来是一道区间修改+暴力查询的zz题

但是因为数据较大

需要离散化技巧

对于每个距离>1的点 需要在离散时+1

不然会有反例出现

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#define inf 2139062143
#define ll long long
#define MAXN 40100
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)) {if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch)) {x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int T,n,ar[MAXN],cnt,ans,vis[MAXN];
struct data {int pos,val;}g[MAXN];
bool cmp(data a,data b) {return a.val<b.val;}
namespace seg_tree
{
    int tag[MAXN<<2];
    void pshd(int k)
    {
        tag[k<<1]=tag[k<<1|1]=tag[k];
        tag[k]=0;
    }
    void mdf(int k,int a,int b,int l,int r,int x)
    {
        //cout<<a<<" "<<b<<" "<<l<<" "<<r<<" "<<x<<endl;
        if(l==a&&r==b) {tag[k]=x;return ;}
        int mid=(l+r)>>1;
        if(tag[k]) pshd(k);
        if(b<=mid) mdf(k<<1,a,b,l,mid,x);
        else if(a>mid) mdf(k<<1|1,a,b,mid+1,r,x);
        else {mdf(k<<1,a,mid,l,mid,x);mdf(k<<1|1,mid+1,b,mid+1,r,x);}
    }
    void query(int k,int l,int r)
    {
        //cout<<k<<" "<<l<<" "<<r<<" "<<tag[k]<<" "<<ans<<endl;
        if(tag[k])
        {
            if(!vis[tag[k]]) ans++,vis[tag[k]]=1;
            return ;
        }
        if(l==r) return ;
        int mid=(l+r)>>1;
        query(k<<1,l,mid);query(k<<1|1,mid+1,r);
    }
}
using namespace seg_tree;
int main()
{
    T=read();
    while(T--)
    {
        memset(vis,0,sizeof(vis));
        memset(tag,0,sizeof(tag));
        n=read(),cnt=ans=0;
        for(int i=1;i<=n;i++) g[i*2-1].val=read(),g[i*2].val=read(),g[i*2-1].pos=i*2-1,g[i*2].pos=i*2;
        sort(g+1,g+2*n+1,cmp);
        for(int i=1;i<=2*n;i++)
            if(g[i].val!=g[i-1].val) cnt+=1+(g[i].val-g[i-1].val>1),ar[g[i].pos]=cnt;
            else ar[g[i].pos]=cnt;
        //for(int i=1;i<=2*n;i++) cout<<ar[i]<<" ";
        for(int i=1;i<=n;i++) mdf(1,ar[i*2-1],ar[i*2],1,cnt,i);
        query(1,1,cnt);
        printf("%d
",ans);
    }
}

⑤ 酒店Hotel luogu 2864

题目大意：

第一行输入n，m ，n代表有n个房间，开始都为空房，m表示以下有m行操作，以下 每行先输入一个数 i ，表示一种操作

若i为1，表示查询房间，再输入一个数x，表示在1--n 房间中找到长度为x的连续空房，输出连续x个房间中左端的房间号

尽量让这个房间号最小，若找不到长度为x的连续空房，输出0

若i为2，表示退房，再输入两个数 x，y 代表 房间号 x---x+y-1 退房，即让房间为空

思路：

与小白逛公园类似

只不过这一次要维护每一段最多有多少个连续的0

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#define inf 2139062143
#define ll long long
#define MAXN 50100
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)) {if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch)) {x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int n,T;
struct data {int lm,rm,tag,ans;}tr[MAXN<<2];
void upd(int k,int l,int r)
{
    int mid=(l+r)>>1;
    tr[k].lm= (tr[k<<1].lm==mid-l+1)?mid-l+1+tr[k<<1|1].lm:tr[k<<1].lm;
    tr[k].rm= (tr[k<<1|1].rm==r-mid)?r-mid+tr[k<<1].rm:tr[k<<1|1].rm;
    tr[k].ans= max(tr[k<<1].rm+tr[k<<1|1].lm,max(tr[k<<1].ans,tr[k<<1|1].ans));
}
void build(int k,int l,int r)
{
    tr[k].lm=tr[k].rm=tr[k].ans=r-l+1,tr[k].tag=0;
    if(l==r) return ;
    int mid=(l+r)>>1;
    build(k<<1,l,mid);build(k<<1|1,mid+1,r);
}
void pshd(int k,int l,int r)
{
    //cout<<"P : "<<k<<endl;
    int mid=(l+r)>>1;
    if(tr[k].tag&1) tr[k<<1].lm=tr[k<<1].rm=tr[k<<1].ans=mid-l+1,tr[k<<1|1].lm=tr[k<<1|1].rm=tr[k<<1|1].ans=r-mid;
    else tr[k<<1].lm=tr[k<<1].rm=tr[k<<1].ans=tr[k<<1|1].lm=tr[k<<1|1].rm=tr[k<<1|1].ans=0;
    tr[k<<1].tag=tr[k<<1|1].tag=tr[k].tag;
    tr[k].tag=0;
}
void mdf(int k,int a,int b,int x,int l,int r)
{
    //cout<<"M : "<<k<<" "<<a<<" "<<b<<" "<<x<<" "<<l<<" "<<r<<" "<<tr[k].ans<<" "<<tr[k].tag<<endl;
    if(l==a&&b==r)
    {
        if(x&1) tr[k].tag=1,tr[k].lm=tr[k].rm=tr[k].ans=r-l+1;
        else tr[k].tag=2,tr[k].lm=tr[k].rm=tr[k].ans=0;
        return ;
    }
    int mid=(l+r)>>1;
    if(tr[k].tag) pshd(k,l,r);
    if(b<=mid) mdf(k<<1,a,b,x,l,mid);
    else if(a>mid) mdf(k<<1|1,a,b,x,mid+1,r);
    else {mdf(k<<1,a,mid,x,l,mid);mdf(k<<1|1,mid+1,b,x,mid+1,r);}
    upd(k,l,r);
}
int query(int k,int x,int l,int r)
{
    //cout<<"Q : "<<k<<" "<<x<<" "<<l<<" "<<r<<" "<<tr[k].ans<<endl;
    if(tr[k].ans<x) return 0;
    int mid=(l+r)>>1;
    if(tr[k].tag) pshd(k,l,r);
    if(tr[k<<1].ans>=x) return query(k<<1,x,l,mid);
    else if(tr[k<<1].rm+tr[k<<1|1].lm>=x) return mid-tr[k<<1].rm+1;
    else return query(k<<1|1,x,mid+1,r);
}
int main()
{
    n=read(),T=read();int a,b,c;
    build(1,1,n);
    while(T--)
    {
        a=read(),b=read();
        if(a&1) 
        {
            c=query(1,b,1,n);
            printf("%d
",c);
            if(c) mdf(1,c,c+b-1,2,1,n);
        }
        else 
        {
            c=read();
            mdf(1,b,b+c-1,1,1,n);
        }
    }
}