ACM之路（14）—— 线段树的日常（上）

　　我的线段树简直有毒，各种错误都能忙上半天。做了kuangbin的线段树专题的一半，还有一半留到以后去做。

　　链接：http://acm.hust.edu.cn/vjudge/contest/view.action?cid=66989#overview

　　总结一下题目吧：

　　A和B都是最简单的线段树，也没有成段更新。A就是维护一段区间的和，B题就是维护一段区间的最大值。这两题直接给出代码，当做一个模板吧。

　　A：

#include <stdio.h>
#include <algorithm>
#include <string.h>
using namespace std;
#define t_mid (l+r >> 1)
#define ls (o<<1)
#define rs (o<<1 | 1)
#define lson ls,l,t_mid
#define rson rs,t_mid+1,r

const int N = 50000+5;
int a[N];
int c[N<<2];

void up(int o) {c[o]=c[ls]+c[rs];}
int build(int o,int l,int r)
{
    if(l==r) return c[o]=a[l];
    return c[o] = build(lson) + build(rson);
}
void update(int o,int l,int r,int pos,int dt)
{
    if(l==r)
    {
        c[o]+=dt;
        return;
    }
    if(pos <= t_mid) update(lson,pos,dt);
    if(pos > t_mid) update(rson,pos,dt);
    up(o);
}
int query(int o,int l,int r,int ql,int qr)
{
    if(ql == l && qr == r) return c[o];
    int res = 0;
    if(qr<=t_mid) res+=query(lson,ql,qr);
    else if(ql>t_mid) res+=query(rson,ql,qr);
    else
    {
        res+=query(lson,ql,t_mid);
        res+=query(rson,t_mid+1,qr);
    }
    //if(ql <= t_mid) res += query(lson,ql,qr);
    //if(qr > t_mid) res += query(rson,ql,qr);
    /*
        注释掉的地方是另外一种写法，只要把第一行改成
        if(ql <= l && qr >= r) reutrn c[o];
        即可
    */
    return res;
}

int main()
{
    int T;
    scanf("%d",&T);
    for(int kase=1;kase<=T;kase++)
    {
        printf("Case %d:
",kase);
        int n;
        scanf("%d",&n);
        for(int i=1;i<=n;i++) scanf("%d",a+i);
        build(1,1,n);

        char s[15];
        while(scanf("%s",s)==1 && strcmp(s,"End"))
        {
            int x,y;
            scanf("%d%d",&x,&y);
            if(!strcmp(s,"Add")) update(1,1,n,x,y);
            else if(!strcmp(s,"Sub")) update(1,1,n,x,-y);
            else if(!strcmp(s,"Query")) printf("%d
",query(1,1,n,x,y));
        }
    }
}

　　B:

#include <stdio.h>
#include <algorithm>
#include <string.h>
using namespace std;
#define t_mid (l+r >> 1)
#define ls (o<<1)
#define rs (o<<1 | 1)
#define lson ls,l,t_mid
#define rson rs,t_mid+1,r

const int N = 200000+5;
int a[N];
int c[N<<2];

void up(int o) {c[o]=max(c[ls],c[rs]);}
int build(int o,int l,int r)
{
    if(l==r) return c[o]=a[l];
    return c[o] = max(build(lson),build(rson));
}
void update(int o,int l,int r,int pos,int dt)
{
    if(l==r)
    {
        c[o]=dt;
        return;
    }
    if(pos <= t_mid) update(lson,pos,dt);
    if(pos > t_mid) update(rson,pos,dt);
    up(o);
}
int query(int o,int l,int r,int ql,int qr)
{
    if(ql <= l && qr >= r) return c[o];
    int r1=0,r2=0;
    if(ql <= t_mid) r1 = query(lson,ql,qr);
    if(qr > t_mid) r2 = query(rson,ql,qr);
    return max(r1,r2);
}

int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m)==2)
    {
        for(int i=1;i<=n;i++) scanf("%d",a+i);
        build(1,1,n);

        while(m--)
        {
            char s[15];
            scanf("%s",s);
            int x,y;
            scanf("%d%d",&x,&y);
            if(!strcmp(s,"U")) update(1,1,n,x,y);
            else if(!strcmp(s,"Q")) printf("%d
",query(1,1,n,x,y));
        }
    }
}

　　然后看一下F题，要求维护的是区间内最大的和最小的差值，那么其实维护的就是区间的最小值和最大值。然后在所需区间相减即可。

　　具体见代码：

#include <stdio.h>
#include <algorithm>
#include <set>
#include <vector>
#include <map>
#include <string.h>
#define t_mid (l+r>>1)
#define ls (o<<1)
#define rs (o<<1 | 1)
#define lson ls,l,t_mid
#define rson rs,t_mid+1,r
using namespace std;

const int N = 1000000 + 5;

struct node
{
    int a,b;
}c[N<<2];
int h[N];

node get(node a,node b)
{
    node ans;
    ans.a = max(a.a,b.a);
    ans.b = min(a.b,b.b);
    return ans;
}

node build(int o,int l,int r)
{
    if(l==r) return c[o]=(node){h[l],h[l]};
    node a = build(lson);
    node b = build(rson);
    return c[o] = get(a,b);
}

node query(int o,int l,int r,int ql,int qr)
{
    if(l==ql && r==qr)
    {
        return c[o];
    }
    
    node res;
    if(qr <= t_mid) res=query(lson,ql,qr);
    else if(ql > t_mid) res=query(rson,ql,qr);
    else
    {
        res=get(query(lson,ql,t_mid),query(rson,t_mid+1,qr));
    }
    return res;
}

int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m)==2)
    {

        for(int i=1;i<=n;i++) scanf("%d",h+i);
        build(1,1,n);

        while(m--)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            node ans = query(1,1,n,x,y);
            printf("%d
",ans.a-ans.b);
        }
    }
}

　　然后就是成段更新的问题了，C和E。要注意的是add数组（或者叫做懒惰标记要清空一下）。

　　这里就给出C题代码：

#include <stdio.h>
#include <algorithm>
#include <string.h>
using namespace std;
#define t_mid (l+r >> 1)
#define ls (o<<1)
#define rs (o<<1 | 1)
#define lson ls,l,t_mid
#define rson rs,t_mid+1,r
typedef long long ll;

const int N = 100000+5;
ll a[N];
ll c[N<<2],add[N<<2];

void up(int o) {c[o] = c[ls] + c[rs];}
void down(int o,int len)
{
    if(add[o])
    {
        add[ls] += add[o];
        add[rs] += add[o];
        c[ls] += add[o] * (len - (len >> 1) );
        c[rs] += add[o] * (len >> 1);
        add[o]=0;
    }
}
ll build(int o,int l,int r)
{
    if(l==r) return c[o]=a[l];
    return c[o] = build(lson) + build(rson);
}
void update(int o,int l,int r,int ql,int qr,ll dt)
{
    if(ql == l && qr == r)
    {
        add[o] += dt;
        c[o] += dt * (r-l+1);
        return;
    }
    down(o,r-l+1);
    if(qr <= t_mid) update(lson,ql,qr,dt);
    else if(ql>t_mid) update(rson,ql,qr,dt);
    else
    {
        update(lson,ql,t_mid,dt);
        update(rson,t_mid+1,qr,dt);
    }
    up(o);
}
ll query(int o,int l,int r,int ql,int qr)
{
    if(ql == l && qr == r) return c[o];
    down(o,r-l+1);
    ll res = 0;
    if(qr <= t_mid) res+=query(lson,ql,qr);
    else if(ql>t_mid) res+=query(rson,ql,qr);
    else
    {
        res+=query(lson,ql,t_mid);
        res+=query(rson,t_mid+1,qr);
    }
    return res;
}
void init()
{
    memset(add,0,sizeof(add));
}

int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m)==2)
    {
        init();

        for(int i=1;i<=n;i++) scanf("%I64d",a+i);
        build(1,1,n);

        while(m--)
        {
            char s[15];
            scanf("%s",s);
            if(s[0]=='C')
            {
                int x,y;
                ll dt;
                scanf("%d%d%I64d",&x,&y,&dt);
                update(1,1,n,x,y,dt);
            }
            else
            {
                int x,y;
                scanf("%d%d",&x,&y);
                printf("%I64d
",query(1,1,n,x,y));
            }
        }
    }
}

　　接着其他几题都是比较零散的问题，先看D。这是一个离散化的问题，因为有些区间过长所以离散化成小区间，然后再用线段树，注意这里有个离散技巧，在离散化以后，如果两点间距离相差大于1，就把小的一点+1的值也作为离散后的点这样可以有效的防止有些区间被漏过去，比方说先涂色1-10，再1-4，最后6-10，这样的话如果不这么处理5这个区间就被盖过去了。其实现在讲起来还是有点迷糊，就先这样吧，以后再看。还要注意的是一个地方unique去重的话返回的是最后一个不重复元素的下一个地址，因此要求不重复元素的个数的话要减去的是第一个元素的下标就好了。

　　具体见代码吧：

#include <stdio.h>
#include <algorithm>
#include <set>
#include <vector>
#include <map>
#include <string.h>
#define t_mid (l+r>>1)
#define ls (o<<1)
#define rs (o<<1 | 1)
#define lson ls,l,t_mid
#define rson rs,t_mid+1,r
using namespace std;

const int N = 10000 + 5;

int c[N<<4];
bool vis[N];
int arr[N<<4];
int pl[N],pr[N];
int ans=0;

void pushDown(int o)
{
    if(c[o]!=-1)
    {
        c[ls]=c[rs]=c[o];
        c[o]=-1;
    }
}
void update(int o,int l,int r,int ql,int qr,int dt)
{
    if(ql == l && qr == r)
    {
        c[o] = dt;
        return;
    }
    pushDown(o);
    if(qr <= t_mid) update(lson,ql,qr,dt);
    else if(ql > t_mid) update(rson,ql,qr,dt);
    else
    {
        update(lson,ql,t_mid,dt);
        update(rson,t_mid+1,qr,dt);
    }
}
void query(int o,int l,int r)
{
    if(c[o]!=-1)
    {
        if(!vis[c[o]])
        {
            vis[c[o]]=1;
            ans++;
        }
        return;
    }
    if(l==r) return;
    query(lson);
    query(rson);
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int n;
        scanf("%d",&n);
        memset(vis,0,sizeof(vis));
        memset(c,-1,sizeof(c));

        int sit=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%d%d",&pl[i],&pr[i]);
            arr[++sit] = pl[i];
            arr[++sit] = pr[i];
        }
        sort(arr+1,arr+1+sit);
        int num = unique(arr+1,arr+1+sit)-(arr+1);

        for(int i=num;i>=2;i--)
        {
            if(arr[i]-arr[i-1] > 1) arr[++num] = arr[i-1] + 1;
        }
        sort(arr+1,arr+1+num);

        for(int i=1;i<=n;i++)
        {
            int l = lower_bound(arr+1,arr+1+num,pl[i])-arr;
            int r = lower_bound(arr+1,arr+1+num,pr[i])-arr;
            update(1,1,num,l,r,i);
        }

        ans=0;
        query(1,1,num);
        printf("%d
",ans);
    }
}

　　G题是对一个区间每次都开根号的进行操作，思路是就算是一个long long的整数，开8次根号也就变成1了，那么对于都是1的区间就不需要递归了，但是这题也不知道为什么无限WA，留着以后再看。另外这题有毒的一个地方在于，每次给出的区间不一定是后面的大于前面的！。。

　　代码如下：

#include <stdio.h>
#include <algorithm>
#include <set>
#include <math.h>
#include <vector>
#include <map>
#include <string.h>
#define t_mid (l+r>>1)
#define ls (o<<1)
#define rs (o<<1 | 1)
#define lson ls,l,t_mid
#define rson rs,t_mid+1,r
using namespace std;
typedef long long ll;

const int N = 100000 + 5;

ll c[N<<4];
ll a[N];

int build(int o,int l,int r)
{
    if(l==r) return c[o]=a[l];
    return c[o] = build(lson) + build(rson);
}
void pushup(int o) {c[o]=c[ls]+c[rs];}
void update(int o,int l,int r,int ql,int qr)
{
    if(l==ql && r==qr && (ll)(r-l+1) == c[o])
    {
        return;
    }
    else if(l==r) {c[o] = (ll)(sqrt((double)c[o]));return;}
    
    if(qr <= t_mid) update(lson,ql,qr);
    else if(ql > t_mid) update(rson,ql,qr);
    else
    {
        update(lson,ql,t_mid);
        update(rson,t_mid+1,qr);
    }
    pushup(o);
}
ll query(int o,int l,int r,int ql,int qr)
{
    if(l==ql && r==qr)
    {
        return c[o];
    }
    
    ll res=0;
    if(qr <= t_mid) res=query(lson,ql,qr);
    else if(ql > t_mid) res=query(rson,ql,qr);
    else
    {
        res = query(lson,ql,t_mid) + query(rson,t_mid+1,qr);
    }
    return res;
}

int main()
{
    int n,m;
    int cnt=1;
    while(scanf("%d",&n)==1)
    {
        printf("Case #%d:
",cnt++);
        for(int i=1;i<=n;i++) scanf("%I64d",a+i);
        build(1,1,n);

        scanf("%d",&m);
        while(m--)
        {
            int x,y,z;
            scanf("%d%d%d",&z,&x,&y);
            if(z==0) update(1,1,n,min(x,y),max(x,y));
            else printf("%I64d
",query(1,1,n,min(x,y),max(x,y)));
        }
        puts("");
    }
}

　　H题是一个很奥义的题，题目意思是每次可以拆村庄或者恢复最后一个被破坏的村庄，询问的话就是询问村庄x附近最多有多少个连续的村庄。解释一下代码里面的数组的含义吧：lsum的意思是这个区间里面从最左边开始有多少个连续的村庄，rsum是从右边开始，msum是在这个区间里面最多有多少个连续的村庄。明白了这些以后代码就可以看懂了。具体见代码：

#include <stdio.h>
#include <algorithm>
#include <set>
#include <math.h>
#include <vector>
#include <stack>
#include <map>
#include <string.h>
#define t_mid (l+r>>1)
#define ls (o<<1)
#define rs (o<<1 | 1)
#define lson ls,l,t_mid
#define rson rs,t_mid+1,r
using namespace std;
typedef long long ll;
const int N = 50000 + 5;

stack<int> S;
int lsum[N<<2],rsum[N<<2],msum[N<<2],c[N<<2];

void build(int o,int l,int r)
{
    lsum[o]=rsum[o]=msum[o]=r-l+1;
    if(l==r) return;
    build(lson);
    build(rson);
}
int query(int o,int l,int r,int ind)
{
    if(l==r || msum[o]==0 || msum[o]==r-l+1) return msum[o];
    if(ind <= t_mid)
    {
        if(ind >= t_mid-rsum[ls]+1)
        {
            return query(lson,ind) + query(rson,t_mid+1); //t_mid+1查右边第一点的连续情况
        }
        else
        {
            return query(lson,ind);
        }
    }
    else
    {
        if(ind <= t_mid+lsum[rs])
        {
            return query(lson,t_mid) + query(rson,ind); //t_mid查左边第一点的连续情况
        }
        else
        {
            return query(rson,ind);
        }
    }
}
void update(int o,int l,int r,int ind,int f)
{
    if(l==r)
    {
        lsum[o]=rsum[o]=msum[o]=f;
        return;
    }

    if(ind <= t_mid) update(lson,ind,f);
        else update(rson,ind,f);

    if(t_mid - l + 1 == lsum[ls]) lsum[o] = lsum[ls] + lsum[rs];
        else lsum[o] = lsum[ls];
    if(r - t_mid == rsum[rs]) rsum[o] = rsum[rs] + rsum[ls];
        else rsum[o] = rsum[rs];

    msum[o] = max(max(msum[ls],msum[rs]),rsum[ls]+lsum[rs]);
}

int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m)==2)
    {
        while(!S.empty()) S.pop();
        build(1,1,n);

        while(m--)
        {
            char s[10];
            scanf("%s",s);
            if(s[0] == 'R')
            {
                int x = S.top();S.pop();
                update(1,1,n,x,1);
            }
            else
            {
                int x;
                scanf("%d",&x);
                if(s[0] == 'D')
                {
                    update(1,1,n,x,0);
                    S.push(x);
                }
                else
                {
                    printf("%d
",query(1,1,n,x));
                }
            }
        }
    }
}

　　I题是用dfs序号维护的线段树，比较有意思。题意是给一个有向图，每次对x点涂色，该点和其下面的点都会被涂色，然后查询时查询某点的颜色。思路就是先得出dfs序，然后如果更新某点的颜色，就update这点的区间为该点的起始时间和终了之间，因为在这个时间内访问的节点恰恰为这点和他的子节点。同时，要查询颜色的话就是把这点的起始时间当做节点号访问就行。具体见代码：

#include <stdio.h>
#include <algorithm>
#include <set>
#include <math.h>
#include <vector>
#include <stack>
#include <map>
#include <string.h>
#define t_mid (l+r>>1)
#define ls (o<<1)
#define rs (o<<1 | 1)
#define lson ls,l,t_mid
#define rson rs,t_mid+1,r
using namespace std;
typedef long long ll;
const int N = 50000 + 5;

vector<int> G[N];
int n,dfs_clock,st[N],ed[N],add[N<<2],c[N<<2];
bool use[N];

void init()
{
    dfs_clock=0;
    for(int i=1;i<=n;i++) G[i].clear();
    memset(st,0,sizeof(st));
    memset(ed,0,sizeof(ed));
    memset(use,0,sizeof(use));
}
void build(int o,int l,int r)
{
    c[o]=add[o]=-1;
    if(l==r) return;
    build(lson);
    build(rson);
}
void pushdown(int o)
{
    if(add[o] != -1)
    {
        add[ls]=add[rs]=add[o];
        c[ls]=c[rs]=add[o];
        add[o]=-1;
    }
}
void dfs(int u)
{
    st[u]=++dfs_clock;
    for(int i=0;i<G[u].size();i++)
    {
        int v = G[u][i];
        dfs(v);
    }
    ed[u]=dfs_clock;
}
void update(int o,int l,int r,int ql,int qr,int f)
{
    if(ql <= l && qr >= r)
    {
        c[o] = f;
        add[o] = f;
        return;
    }
    pushdown(o);
    if(ql <= t_mid) update(lson,ql,qr,f);
    if(qr > t_mid) update(rson,ql,qr,f);
}
int query(int o,int l,int r,int ind)
{
    if(l==r) return c[o];
    pushdown(o);
    if(ind <= t_mid) return query(lson,ind);
        else return query(rson,ind);
}

int main()
{
    int T,m;
    scanf("%d",&T);
    for(int kase=1;kase<=T;kase++)
    {
        printf("Case #%d:
",kase);
        init();

        scanf("%d",&n);
        for(int i=1;i<n;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            G[v].push_back(u);
            use[u]=1;
        }
        for(int i=1;i<=n;i++) if(!use[i]) dfs(i);
        build(1,1,n);

        char s[10];
        scanf("%d",&m);
        while(m--)
        {
            scanf("%s",s);
            if(s[0] == 'C')
            {
                int x;
                scanf("%d",&x);
                printf("%d
",query(1,1,n,st[x]));
            }
            else
            {
                int x,y;
                scanf("%d%d",&x,&y);
                update(1,1,n,st[x],ed[x],y);
            }
        }
    }
    return 0;
}

　　J题题意很简单，就是区间操作还有乘法。那么思路就是，用变量记录一段区间值是不是相等，相等的话只要记录下这次操作变化了多少就可以，不相等就递归下去，不过这题细节也挺多的，反正无限WA，留着以后再看。这题真是有毒！。。代码如下：

#include <stdio.h>
#include <algorithm>
#include <set>
#include <math.h>
#include <vector>
#include <stack>
#include <map>
#include <string.h>
#define t_mid (l+r>>1)
#define ls (o<<1)
#define rs (o<<1 | 1)
#define lson ls,l,t_mid
#define rson rs,t_mid+1,r
using namespace std;
typedef long long ll;
const int N = 100000 + 5;
const int mod = 10007;

ll add[N<<2],mul[N<<2],ch[N<<2],c[N<<2]; //ch表示这一段是否都是一个值,c表示这一段都是这一个数

void build(int o,int l,int r)
{
    mul[o]=1;
    add[o]=c[o]=ch[o]=0; //我觉得这里的ch[o]应该等于1，但是AC代码是0，而且答案都一样。
    if(l==r)
    {
        ch[o]=1;
        return;
    }
    build(lson);
    build(rson);
}

void pushdown(int o,int l,int r)
{
    if(l==r) return;
    if(ch[o])
    {
        add[ls]=0,mul[ls]=1;
        add[rs]=0,mul[rs]=1;
        ch[ls]=ch[rs]=1;
        c[ls]=c[rs]=c[o];
        ch[o]=0;
    }
    else
    {
        if(add[o])
        {
            if(ch[ls]) c[ls] = (c[ls]+add[o]) % mod;
            else
            {
                pushdown(lson);
                add[ls]=(add[o]+add[ls]) % mod;
            }

            if(ch[rs]) c[rs] = (c[rs]+add[o]) % mod;
            else
            {
                pushdown(rson);
                add[rs]=(add[o]+add[rs]) % mod;
            }
            add[o]=0;
        }

        if(mul[o]>1)
        {
            if(ch[ls]) c[ls]=(c[ls]*mul[o]) % mod;
            else
            {
                pushdown(lson);
                mul[ls]=(mul[o]*mul[ls]) % mod;
            }

            if(ch[rs]) c[rs]=(c[rs]*mul[o]) % mod;
            else
            {
                pushdown(rson);
                mul[rs]=(mul[o]*mul[rs]) % mod;
            }
            mul[o]=1;
        }
    }
}

void update(int o,int l,int r,int ql,int qr,int f,int op)
{
    if(ql <= l && qr >= r)
    {
        if(op == 3)
        {
            ch[o]=1,c[o]=f;
            mul[o]=1,add[o]=0;
        }
        else
        {
            if(ch[o])
            {
                if(op == 1) c[o]=(c[o]+f)%mod;
                    else c[o]=c[o]*f%mod;
            }
            else
            {
                pushdown(o,l,r);
                if(op == 1) add[o]=(c[o]+f)%mod;
                    else mul[o]=mul[o]*f%mod;
            }
        }
        return;
    }

    pushdown(o,l,r);
    if(ql <= t_mid) update(lson,ql,qr,f,op);
    if(qr > t_mid) update(rson,ql,qr,f,op);
}

ll query(int o,int l,int r,int ql,int qr,int p)
{
    if(ql <= l && qr >= r)
    {
        if(ch[o])
        {
            ll ans = 1,t=c[o];
            for(int i=1;i<=p;i++) ans = ans * t % mod;
            return (r-l+1) * ans % mod;
        }
    }

    pushdown(o,l,r);
    ll ans = 0;
    if(ql <= t_mid) ans += query(lson,ql,qr,p);
    if(qr > t_mid) ans += query(rson,ql,qr,p);
    return ans % mod;
}
int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m)==2)
    {
        if(n==0 && m==0) break;
        build(1,1,n);
        while(m--)
        {
            int op,x,y,f;
            scanf("%d%d%d%d",&op,&x,&y,&f);
            if(op<=3) update(1,1,n,x,y,f,op);
                else printf("%I64d
",query(1,1,n,x,y,f));
        }
    }
    return 0;
}

　　哎，线段树真的好烦！。。