线段树经典类型归纳

第一道：

HDU 1754 单点更新，区间查询最大值，水题……

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
#include<cmath>
#include<bitset>
#define mem(a,b) memset(a,b,sizeof(a))
#define lson i<<1,l,mid
#define rson i<<1|1,mid+1,r
#define INF 1000000
#define maxn 1000010
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int Max[maxn],a[200005],n,m,i;
void pushup(int i)
{
    Max[i]=max(Max[i<<1],Max[i<<1|1]);
}
void build(int i,int l,int r)
{
    if(l==r)
    {
        Max[i]=a[l];
        return ;
    }
    int mid=(l+r)>>1;
    build(lson);build(rson);
    pushup(i);
}
void update(int i,int l,int r,int x,int v)
{
    if(l==r&&l==x)
    {
        Max[i]=v;
        return ;
    }
    int mid=(l+r)>>1;
    if(x<=mid) update(lson,x,v);
    else update(rson,x,v);
    pushup(i);
}
int query(int i,int l,int r,int L,int R)
{
    if(L<=l&&r<=R) return Max[i];
    int mid=(l+r)>>1,ans=0;
    if(L<=mid) ans=max(ans,query(lson,L,R));
    if(R>mid) ans=max(ans,query(rson,L,R));
    return ans;
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        for(i=1;i<=n;i++)
            scanf("%d",a+i);
        build(1,1,n);
        int x,y;
        char str[3];
        while(m--)
        {
            scanf("%s%d%d",str,&x,&y);
            if(str[0]=='Q')
                printf("%d\n",query(1,1,n,x,y));
            else update(1,1,n,x,y);
        }
    }
    return 0;
}

第二道：

HDU 1698 区间更新，区间查询，lazy标记种类，水……

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
#include<cmath>
#include<bitset>
#define mem(a,b) memset(a,b,sizeof(a))
#define lson i<<1,l,mid
#define rson i<<1|1,mid+1,r
#define INF 1000000
#define maxn 400010
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int sum[maxn],lazy[maxn],n,q;
void pushup(int i)
{
    sum[i]=sum[i<<1]+sum[i<<1|1];
}
void pushdown(int i,int l,int r)
{
    if(lazy[i])
    {
        int mid=(l+r)>>1;
        lazy[i<<1]=lazy[i<<1|1]=lazy[i];
        sum[i<<1]=(mid-l+1)*lazy[i<<1];
        sum[i<<1|1]=(r-mid)*lazy[i<<1|1];
        lazy[i]=0;
    }
}
void update(int i,int l,int r,int L,int R,int v)
{
    if(l==L&&r==R)
    {
        sum[i]=(r-l+1)*v;
        lazy[i]=v;
        return ;
    }
    int mid=(l+r)>>1;
    pushdown(i,l,r);
    if(R<=mid) update(lson,L,R,v);
    else if(L>mid) update(rson,L,R,v);
    else
    {
        update(lson,L,mid,v);
        update(rson,mid+1,R,v);
    }
    pushup(i);
}
void build(int i,int l,int r)
{
    if(l==r)
    {
        sum[i]=1;
        lazy[i]=1;
        return ;
    }
    sum[i]=lazy[i]=0;
    int mid=(l+r)>>1;
    build(lson);build(rson);
    pushup(i);
}
int main()
{
    int t;
    cin>>t;
    for(int i=1;i<=t;i++)
    {
        scanf("%d%d",&n,&q);
        build(1,1,n);
        int l,r,v;
        while(q--)
        {
            scanf("%d%d%d",&l,&r,&v);
            update(1,1,n,l,r,v);
        }
        printf("Case %d: The total value of the hook is %d.\n",i,sum[1]);
    }
    return 0;
}

第三道：

HDU 1394 单点更新，区间查询，线段树、树状数组、归并排序求逆序数。

解法一：线段树

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
#include<cmath>
#include<bitset>
#define mem(a,b) memset(a,b,sizeof(a))
#define lson i<<1,l,mid
#define rson i<<1|1,mid+1,r
#define INF 1000000007
#define maxn 400010
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int sum[20005],a[5005];
void update(int i,int l,int r,int x,int v)
{
    sum[i]+=v;
    if(l==r) return ;
    int mid=(l+r)>>1;
    if(x<=mid) update(lson,x,v);
    else update(rson,x,v);
}
int query(int i,int l,int r,int L,int R)
{
    if(l==L&&r==R) return sum[i];
    int mid=(l+r)>>1;
    if(R<=mid) return query(lson,L,R);
    else if(L>mid) return query(rson,L,R);
    else return query(lson,L,mid)+query(rson,mid+1,R);
}
int main()
{
    int n,i;
    while(~scanf("%d",&n))
    {
        int ans=0,Min=INF;
        mem(sum,0);
        for(i=1;i<=n;i++)
        {
            scanf("%d",a+i),a[i]++;
            ans+=query(1,1,n,a[i],n);
            update(1,1,n,a[i],1);
        }
        Min=min(Min,ans);
        for(i=1;i<=n;i++)
        {
            ans-=a[i]-1;
            ans+=n-a[i];
            Min=min(Min,ans);
        }
        printf("%d\n",Min);
    }
    return 0;
}

解法二：树状数组：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
#include<cmath>
#include<bitset>
#define mem(a,b) memset(a,b,sizeof(a))
#define lson i<<1,l,mid
#define rson i<<1|1,mid+1,r
#define INF 1000000007
#define maxn 400010
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int n,c[maxn],a[maxn];
void update(int x)
{
    for(int i=x;i;c[i]+=1,i-=i&(-i));
    //更新x之前的,这样查询x+1之后的数才会查询不到逆序数
}
int query(int x)
{
    int i,sum=0;
    for(i=x;i<=n;sum+=c[i],i+=i&(-i));
    return sum;
}
int main ()
{
    while(~scanf("%d",&n))
    {
        int i,sum=0,Min=INF;
        mem(c,0);
        for(i=1;i<=n;i++)
        {
            scanf("%d",a+i),a[i]++;
            sum+=query(a[i]);
            update(a[i]);
        }
        Min=min(sum,Min);
        for(i=1;i<=n;i++)
        {
            sum-=a[i]-1;
            sum+=n-a[i];
            Min=min(sum,Min);
        }
        printf("%d\n",Min);
    }
    return 0;
}

第四道：

POJ 2528 线段树+离散化

这题T了几个小时了，晕死了……原来是在离散化的时候多了点时间，尼玛，让我debug了两个小时！！！！

其实我这样离散化还有个bug，因为单点离散化和区间离散化是不一样的。

比如这个例子：

3

1 10

1 3

6 10

我这个代码就输出2，本来是3的，POJ 的数据弱了。

不过改一点就可以过了，离散化的时候可以离散成：Map[c[i]]=（i+1）*2，然后查询的时候，总区间也*2就行了，这样在区间与区间之间就可以查询得到了。懒得改了，想做好的就按这样做吧。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
#include<cmath>
#include<bitset>
#define mem(a,b) memset(a,b,sizeof(a))
#define lson i<<1,l,mid
#define rson i<<1|1,mid+1,r
#define INF 10000010
#define maxn 80010
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int lazy[maxn];
int a[10005],b[10005],c[20010],num[20010];
set<int>s;
void pushdown(int i,int v)
{
    if(lazy[i]&&lazy[i]!=v)
    {
        lazy[i<<1]=lazy[i<<1|1]=lazy[i];
        lazy[i]=0;
    }
}
void update(int i,int l,int r,int L,int R,int v)
{
    if(l==L&&r==R)
    {
        lazy[i]=v;
        return ;
    }
    int mid=(l+r)>>1;
    pushdown(i,v);
    if(R<=mid) update(lson,L,R,v);
    else if(L>mid) update(rson,L,R,v);
    else
    {
        update(lson,L,mid,v);
        update(rson,mid+1,R,v);
    }
}
void query(int i,int l,int r)
{
    if(lazy[i])
    {
        s.insert(lazy[i]);
        return ;
    }
    if(l==r||lazy[i]==-1) return ;
    int mid=(l+r)>>1;
    query(lson);query(rson);
}
map<int,int>Map;
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int i,n,k=0;
        Map.clear();
        s.clear();
        mem(lazy,0);
        scanf("%d",&n);
        for(i=0;i<n;i++)
        {
            scanf("%d%d",&a[i],&b[i]);
            c[k++]=a[i];
            c[k++]=b[i];
        }
        sort(c,c+k);
        k=unique(c,c+k)-c;
        for(i=0;i<k;i++)
            Map[c[i]]=i+1;
        for(i=0;i<n;i++)
            update(1,1,k,Map[a[i]],Map[b[i]],i+1);
        query(1,1,k);
        printf("%d\n",s.size());
    }
    return 0;
}

第五道：

HDU 2795 几何中的单点更新

思路：刚开始看这题的时候也不知道该怎么用线段树做，想了好久也不知道，然后看了下别人的解题报告才知道这么容易，只是想不到啊！用叶结点表示长方形的行，然后叶结点的域表示的是当前行的宽（或者还剩多少可以容纳的宽度），这样就可以轻松解决了。线段树不建太长，有多少行就建多少，如果n大的话，就建n的长度就行了，这点看刚才看题的时候10^9就怕了，所以就没想到这么机智的做法。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
#include<cmath>
#include<bitset>
#define mem(a,b) memset(a,b,sizeof(a))
#define lson i<<1,l,mid
#define rson i<<1|1,mid+1,r
#define INF 10000010
#define maxn 800010
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int Max[maxn];
void pushup(int i)
{
    Max[i]=max(Max[i<<1],Max[i<<1|1]);
}
void update(int i,int l,int r,int v)
{
    if(l==r)
    {
        printf("%d\n",l);
        Max[i]-=v;
        return ;
    }
    int mid=(l+r)>>1;
    if(Max[i<<1]>=v) update(lson,v);
    else update(rson,v);//用域比较v
    pushup(i);
}
int main()
{
    int h,w,n;
    while(~scanf("%d%d%d",&h,&w,&n))
    {
        int i,len=h<n?h:n;
        for(int i=0;i<len*4+10;i++)
            Max[i]=w;
        while(n--)
        {
            int v;
            scanf("%d",&v);
            if(Max[1]<v) puts("-1");
            else update(1,1,len,v);
        }
    }
    return 0;
}

第六道：

POJ 3667  区间合并，设置左右中区间，然后更新的时候合并。刚开始想的时候确实没想到这么机智的做法，我想的做法是加个lazy标记，然后查询的时候再加个flag标记，初始flag=0，如果找到flag=1，然后如果=1的话，递归就不进行下去了， 这样应该也可以做这道题，不过可能代码比较长忽悠一点吧……

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
#include<cmath>
#include<bitset>
#define mem(a,b) memset(a,b,sizeof(a))
#define lson i<<1,l,mid
#define rson i<<1|1,mid+1,r
#define INF 10000010
#define maxn 200010
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int sum[maxn],lsum[maxn],rsum[maxn],lazy[maxn];
void pushdown(int i,int v)
{
    if(lazy[i]!=-1)
    {
        int l=i<<1,r=i<<1|1;
        lazy[l]=lazy[r]=lazy[i];
        sum[l]=lsum[l]=rsum[l]=(lazy[i]?0:(v-(v>>1)));//lazy为1表清空房间
        sum[r]=lsum[r]=rsum[r]=(lazy[i]?0:(v>>1));//右孩子值
        lazy[i]=-1;
    }
}
void pushup(int i,int v)
{
    int l=i<<1,r=i<<1|1;
    lsum[i]=lsum[l];
    if(lsum[l]==v-(v>>1))//若左子树全空
        lsum[i]+=lsum[r];//则加上右子树的左区间
    rsum[i]=rsum[r];
    if(rsum[r]==v>>1)
        rsum[i]+=rsum[l];
    sum[i]=max(max(sum[l],sum[r]),rsum[l]+lsum[r]);
}
void update(int i,int l,int r,int L,int R,int v)
{
    if(L<=l&&r<=R)
    {
        sum[i]=lsum[i]=rsum[i]=(v?0:r-l+1);
        lazy[i]=v;
        return ;
    }
    pushdown(i,r-l+1);
    int mid=(l+r)>>1;
    if(L<=mid) update(lson,L,R,v);
    if(mid<R) update(rson,L,R,v);
    pushup(i,r-l+1);
}
int query(int i,int l,int r,int v)
{
    if(l==r) return l;
    pushdown(i,r-l+1);
    int mid=(l+r)>>1;
    if(sum[i<<1]>=v) return query(lson,v);
    else if(rsum[i<<1]+lsum[i<<1|1]>=v)
        return mid-rsum[i<<1]+1;
    return query(rson,v);
}
void build(int i,int l,int r)
{
    sum[i]=lsum[i]=rsum[i]=r-l+1;
    lazy[i]=-1;
    if(l==r) return ;
    int mid=(l+r)>>1;
    build(lson);build(rson);
}
int main()
{
    //freopen("test.txt","r",stdin);
    int n,m;
    scanf("%d%d",&n,&m);
    build(1,1,n);
    while(m--)
    {
        int q,l,r;
        scanf("%d%d",&q,&l);
        if(q==1)
        {
            if(sum[1]<l) {puts("0");continue;}
            int k=query(1,1,n,l);
            printf("%d\n",k);
            update(1,1,n,k,k+l-1,1);//住房
        }
        else
        {
            scanf("%d",&r);
            update(1,1,n,l,l+r-1,0);
        }
    }
    return 0;
}

第七道：

POJ 2892  & HDU 1540

解法一：树状数组查找第k小的数的下标。

树状数组查找第k小的数做的，挺机智的。

查找第k小的数，这个知识学习了一下午才知道什么意思，尼玛……其实意思就是查找值为k的数在树状数组中其和从1开始到哪个下标其和等于k。比如树状数组中的：c[1]=1,c[2]=1,c[3]=0,c[4]=1,c[5]=0,c[6]=0,c[7]=1,c[8]=2,c[9]=1.

则sum[5]=1,现在查找k=1的下标，那就是4;再比如sum[8]=2,查找k=2的下标就是8，这个求法可以用下面代码的find_kth函数二分逼近法求出。

但是在HDU 1540上过不了，所说是数据水了。改了一上午还是过不了，还以为是数据有错了，然后拿别人代码交了一发线段树就过了，难道这题限制用树状数组？算了，还是用线段树写发区间合并吧！

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<cmath>
#include<bitset>
#define mem(a,b) memset(a,b,sizeof(a))
#define lowbit(x) (x&-x)
#define INF 1000000
#define maxn 100010
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int c[50010];
void update(int x,int n,int val)
{
    for(; x<=n; x+=lowbit(x))
        c[x]+=val;
}
int sum(int x,int n)
{
    int ans=0;
    for(; x>0; x-=lowbit(x))
        ans+=c[x];
    return ans;
}
int find_kth(int k,int n,int logn)
{
    int cur=0,cnt=0,i;
    for(i=logn; i>=0; i--)
    {
        cur+=1<<i;
        if(cur>n||cnt+c[cur]>=k) cur-=1<<i;
        else cnt+=c[cur];
    }
    return cur+1;
}
int main(void)
{
    int n,m,x;
    char s[2];
    scanf("%d%d",&n,&m);
    stack<int>st;
    n+=2;
    int logn=log(n+1.0)/log(2.0);
    update(1,n,1);
    update(n,n,1);
    while(m--)
    {
        scanf("%s",s);
        if(s[0]=='D')
        {
            scanf("%d",&x);
            x++;
            update(x,n,1);
            st.push(x);
        }
        else if(s[0]=='R')
        {
            x=st.top();
            st.pop();
            update(x,n,-1);
        }
        else
        {
            scanf("%d",&x);
            x++;
            int k=sum(x,n);
            int pre=find_kth(k,n,logn);
            int next=find_kth(k+1,n,logn);
            if(pre==x) puts("0");
            else printf("%d\n",next-pre-1);
        }
    }
    return 0;
}

解法二：线段树区间合并

这个和hotel那题差不多，都是区间合并，代码差不多。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<cmath>
#include<bitset>
#define mem(a,b) memset(a,b,sizeof(a))
#define lson i<<1,l,mid
#define rson i<<1|1,mid+1,r
#define INF 10000010
#define maxn 200010
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int sum[maxn],lsum[maxn],rsum[maxn];
void pushup(int i,int v)
{
    int l=i<<1,r=i<<1|1;
    lsum[i]=lsum[l];
    if(lsum[l]==v-(v>>1))//若左子树全空
        lsum[i]+=lsum[r];//则加上右子树的左区间
    rsum[i]=rsum[r];
    if(rsum[r]==v>>1)
        rsum[i]+=rsum[l];
    sum[i]=max(max(sum[l],sum[r]),rsum[l]+lsum[r]);
}
void update(int i,int l,int r,int x,int v)
{
    if(l==r)
    {
        sum[i]=lsum[i]=rsum[i]=v;
        return ;
    }
    int mid=(l+r)>>1;
    if(x<=mid) update(lson,x,v);
    else update(rson,x,v);
    pushup(i,r-l+1);
}
int query(int i,int l,int r,int v)
{
    if(l==r||sum[i]==0||sum[i]==r-l+1) return sum[i];
    int mid=(l+r)>>1;
    if(v<=mid)
    {
        if(v>=mid-rsum[i<<1]+1)
            return query(lson,v)+query(rson,mid+1);
        else return query(lson,v);
    }
    else
    {
        if(v<=mid+lsum[i<<1|1])
            return query(rson,v)+query(lson,mid);
        else return query(rson,v);
    }
}
void build(int i,int l,int r)
{
    sum[i]=lsum[i]=rsum[i]=r-l+1;
    if(l==r) return ;
    int mid=(l+r)>>1;
    build(lson);
    build(rson);
}
int main()
{
    //freopen("test.txt","r",stdin);
    int n,m;
    while(~scanf("%d%d",&n,&m))
    {
        build(1,1,n);
        stack<int>st;
        while(m--)
        {
            int x;
            char s[2];
            scanf("%s",s);
            if(s[0]=='D')
            {
                scanf("%d",&x);
                st.push(x);
                update(1,1,n,x,0);
            }
            else if(s[0]=='R')
            {
                x=st.top();st.pop();
                update(1,1,n,x,1);
            }
            else
            {
                scanf("%d",&x);
                printf("%d\n",query(1,1,n,x));
            }
        }
    }
    return 0;
}

第八道：

HDU 2871  区间合并 

这题比较晕……靠……刚开始直接输入scanf("%s%d",s,%l);然后一直T，检查了好久都没发现哪里有超时的可能。然后不用文件输入，手动输入的时候才发现Reset后面不用输数字了，尼玛……晕……

与hotel那题的函数是一样的，只不过处理不一样。

不过这里因为是一堆一堆处理的，所以比较麻烦，但是线段树的函数还是不变的。

因为要处理询问一段一段，所以可以把其放进向量vector里记录，加入和删除比较方便。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#define lson i<<1,l,mid
#define rson i<<1|1,mid+1,r
#define maxn 200010
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int sum[maxn],lsum[maxn],rsum[maxn],lazy[maxn];
void pushdown(int i,int v)
{
    if(lazy[i]!=-1)
    {
        int l=i<<1,r=i<<1|1;
        lazy[l]=lazy[r]=lazy[i];
        sum[l]=lsum[l]=rsum[l]=(lazy[i]?0:(v-(v>>1)));//lazy为1表清空房间
        sum[r]=lsum[r]=rsum[r]=(lazy[i]?0:(v>>1));//右孩子值
        lazy[i]=-1;
    }
}
void pushup(int i,int v)
{
    int l=i<<1,r=i<<1|1;
    lsum[i]=lsum[l];
    if(lsum[l]==v-(v>>1))//若左子树全空
        lsum[i]+=lsum[r];//则加上右子树的左区间
    rsum[i]=rsum[r];
    if(rsum[r]==v>>1)
        rsum[i]+=rsum[l];
    sum[i]=max(max(sum[l],sum[r]),rsum[l]+lsum[r]);
}
void update(int i,int l,int r,int L,int R,int v)
{
    if(L<=l&&r<=R)
    {
        sum[i]=lsum[i]=rsum[i]=(v?0:r-l+1);
        lazy[i]=v;
        return ;
    }
    pushdown(i,r-l+1);
    int mid=(l+r)>>1;
    if(L<=mid) update(lson,L,R,v);
    if(mid<R) update(rson,L,R,v);
    pushup(i,r-l+1);
}
int query(int i,int l,int r,int v)
{
    if(sum[i]<v) return 0;
    if(l==r) return l;
    pushdown(i,r-l+1);
    int mid=(l+r)>>1;
    if(sum[i<<1]>=v) return query(lson,v);
    else if(rsum[i<<1]+lsum[i<<1|1]>=v)
        return mid-rsum[i<<1]+1;
    return query(rson,v);
}
void build(int i,int l,int r)
{
    sum[i]=lsum[i]=rsum[i]=r-l+1;
    lazy[i]=-1;
    if(l==r) return ;
    int mid=(l+r)>>1;
    build(lson);
    build(rson);
}
struct block
{
    int Begin,End;
}y;
bool cmp(const block &a,const block &b)
{
    return a.Begin<b.Begin;
}
vector<block>v;
vector<block>::iterator it;
int main()
{
    //freopen("test.txt","r",stdin);
    int n,m;
    while(~scanf("%d%d",&n,&m))
    {
        build(1,1,n);
        v.clear();
        while(m--)
        {
            int l;
            char s[7];
            scanf("%s",&s);
            if(s[0]=='N')
            {
                scanf("%d",&l);
                if(sum[1]<l) { puts("Reject New");continue; }
                int k=query(1,1,n,l);
                printf("New at %d\n",k);
                update(1,1,n,k,k+l-1,1);
                y.Begin=k,y.End=k+l-1;
                it=upper_bound(v.begin(),v.end(),y,cmp);
                v.insert(it,y);
            }
            else if(s[0]=='F')
            {
                scanf("%d",&l);
                y.Begin=l,y.End=l;
                it=upper_bound(v.begin(),v.end(),y,cmp);
                int ii=it-v.begin()-1;
                if(ii==-1||v[ii].End<l)
                    puts("Reject Free");
                else
                {
                    printf("Free from %d to %d\n",v[ii].Begin,v[ii].End);
                    update(1,1,n,v[ii].Begin,v[ii].End,0);
                    v.erase(v.begin()+ii);
                }
            }
            else if(s[0]=='R')
            {
                //build(1,1,n);会超时
                update(1,1,n,1,n,0);
                v.clear();
                puts("Reset Now");
            }
            else
            {
                scanf("%d",&l);
                if(l>v.size()) puts("Reject Get");
                else printf("Get at %d\n",v[l-1].Begin);
            }
        }
        puts("");
    }
    return 0;
}

第九道：

HDU 1542 开始利用线段树求解矩形面积的并、交、以及周长.

刚开始接触这类型的时候，真的不知道该如何下手。没想到线段树还能拿来求解矩形面积的并、交和周长，感觉挺神的，后面就看了这方面的博客，看到一个挺好的解释和代码，研究了一天半才全部搞明白……

先看这个博客前面线段树中结点域的解释，然后边看图边看代码就理解了。

昨天看明白之后，还以为全部理解了，然后今天敲的时候，没得答案，然后把过程都输出了，一个一个对比，然后才发现建树的时候错了。我们一般建树都是build(i<<1,l,mid);build(1<<1|1,mid+1,r);而这个线段树求解矩形的并不这样建的，有点区别。因为这样建树的话，叶子结点l和r相同，就是一个点，而不是线段了，所以要让叶子结点是线段，然后又不能在更新线段的时候变成更新一个点，所以得这样建树：build(1<<1,l,mid);build(1<<1|1,mid,r);建的这个右子树不一样。

学习参考博客：http://www.cnblogs.com/ka200812/archive/2011/11/13/2247064.html

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
#include<cmath>
#include<bitset>
#define mem(a,b) memset(a,b,sizeof(a))
#define lson i<<1,l,mid
#define rson i<<1|1,mid+1,r
#define INF 510010
#define maxn 400010
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
double y[210];
struct line
{
    double x,y1,y2;
    int flag;
}a[210];
bool cmp(line a,line b)
{
    return a.x<b.x;
}
double len[1000];
int lazy[1000];
void pushUp(int i,int l,int r)
{
    if(lazy[i]) len[i]=y[r-1]-y[l-1];
    else if(l+1==r) len[i]=0;//叶子结点
    else len[i]=len[i<<1]+len[i<<1|1];
}
void update(int i,int l,int r,int L,int R,int c)
{
    if(r<=L||l>=R) return ;
    if(L<=l&&r<=R)
    {
        lazy[i]+=c;
        pushUp(i,l,r);
        return;
    }
    int mid=(l+r)>>1;
    update(lson,L,R,c);
    update(i<<1|1,mid,r,L,R,c);//建的树不一样
    pushUp(i,l,r);
}
int main()
{
    //freopen("test.txt","r",stdin);
    int n,ii=1;
    while(scanf("%d",&n)&&n)
    {
        int i;
        double x1,y1,x2,y2,ans=0;
        mem(len,0);mem(lazy,0);
        for(i=0;i<n;i++)
        {
            scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
            y[i<<1]=y1,a[i<<1].x=x1,a[i<<1].y1=y1,a[i<<1].y2=y2,a[i<<1].flag=1;
            y[i<<1|1]=y2,a[i<<1|1].x=x2,a[i<<1|1].y1=y1,a[i<<1|1].y2=y2,a[i<<1|1].flag=-1;
        }
        sort(y,y+n*2); //因为是浮点数,而且数又大，不好建树
        int nn=unique(y,y+n*2)-y;//所以离散化了再建树
        sort(a,a+n*2,cmp);
        printf("Test case #%d\n",ii++);
        for(i=0;i<n*2-1;i++)
        {
            int l=lower_bound(y,y+nn,a[i].y1)-y+1;
            int r=lower_bound(y,y+nn,a[i].y2)-y+1;
            update(1,1,nn,l,r,a[i].flag);
            ans+=len[1]*(a[i+1].x-a[i].x);
        }
        printf("Total explored area: %.2f\n\n",ans);
    }
    return 0;
}

第十道：

HDU 1255 求解矩形并的面积

这题和上一题处理的代码都一样，我还没变呢就过了……算的时候当然是用覆盖两次以上的算啦！在上一题中把线段树节点里面的len域改成覆盖一次和覆盖两次的就行了，覆盖两次以上的肯定有并的了。比较难的处理在pushUp那个函数，只要理解了上一题，这一题应该没有那么难理解了。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
#include<cmath>
#include<bitset>
#define mem(a,b) memset(a,b,sizeof(a))
#define lson i<<1,l,mid
#define rson i<<1|1,mid+1,r
#define INF 510010
#define maxn 800010
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
double y[2010];
struct line
{
    double x,y1,y2;
    int flag;
} a[2010];
bool cmp(line a,line b)
{
    return a.x<b.x;
}
double one_len[maxn],more_len[maxn];//覆盖一次或多次
int lazy[maxn];
void pushUp(int i,int l,int r)
{
    if(lazy[i]>1)
        one_len[i]=more_len[i]=y[r-1]-y[l-1];//覆盖两次以上的话，一次和多次的长度是一样的
    else if(lazy[i]==1)
    {
        one_len[i]=y[r-1]-y[l-1];//一次覆盖
        if(l+1==r) more_len[i]=0;//叶子结点多次覆盖定为0
        else more_len[i]=one_len[i<<1]+one_len[i<<1|1];//因为当前已经有覆盖的话，要是下面的也有覆盖一次，那肯定覆盖两次以上啦，画个图就理解了！
    }
    else
    {
        if(l+1==r)
            more_len[i]=one_len[i]=0;//一次覆盖都没有的时候在叶子都为0
        else
        {
            more_len[i]=more_len[i<<1]+more_len[i<<1|1];
            one_len[i]=one_len[i<<1]+one_len[i<<1|1];//往上传
        }
    }
}
void update(int i,int l,int r,int L,int R,int c)
{
    if(r<=L||l>=R) return ;
    if(L<=l&&r<=R)
    {
        lazy[i]+=c;
        pushUp(i,l,r);
        return;
    }
    int mid=(l+r)>>1;
    update(lson,L,R,c);
    update(i<<1|1,mid,r,L,R,c);//建的树不一样
    pushUp(i,l,r);
}
int main()
{
    //freopen("test.txt","r",stdin);
    int t;
    cin>>t;
    while(t--)
    {
        int n;
        scanf("%d",&n);
        int i;
        double x1,y1,x2,y2,ans=0;
        mem(one_len,0);mem(more_len,0);
        mem(lazy,0);
        for(i=0; i<n; i++)
        {
            scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
            y[i<<1]=y1,a[i<<1].x=x1,a[i<<1].y1=y1,a[i<<1].y2=y2,a[i<<1].flag=1;
            y[i<<1|1]=y2,a[i<<1|1].x=x2,a[i<<1|1].y1=y1,a[i<<1|1].y2=y2,a[i<<1|1].flag=-1;
        }
        sort(y,y+n*2); //因为是浮点数,而且数又大，不好建树
        int nn=unique(y,y+n*2)-y;//所以离散化了再建树
        sort(a,a+n*2,cmp);
        for(i=0; i<n*2-1; i++)
        {
            int l=lower_bound(y,y+nn,a[i].y1)-y+1;
            int r=lower_bound(y,y+nn,a[i].y2)-y+1;
            update(1,1,nn,l,r,a[i].flag);
            ans+=more_len[1]*(a[i+1].x-a[i].x);//用多次覆盖的计算
        }
        printf("%.2f\n",ans);
    }
    return 0;
}

第十一道：

HDU 1828 线段树求矩形并的周长

其实就是用了上面第九道题的模板就A了，哈哈，太爽了。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
#include<cmath>
#include<bitset>
#define mem(a,b) memset(a,b,sizeof(a))
#define lson i<<1,l,mid
#define rson i<<1|1,mid+1,r
#define INF 510010
#define maxn 400010
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
struct line
{
    int x,y1,y2;
    int flag;
}a[maxn/7],b[maxn/7];
bool cmp(line a,line b)
{
    return a.x<b.x;
}
int len[maxn],lazy[maxn],y[maxn/7],x[maxn/7];
void pushUp(int i,int l,int r,int flag)
{
    if(lazy[i])
    {
        if(flag) len[i]=y[r-1]-y[l-1];
        else len[i]=x[r-1]-x[l-1];
    }
    else if(l+1==r) len[i]=0;//叶子结点
    else len[i]=len[i<<1]+len[i<<1|1];
}
void update(int i,int l,int r,int L,int R,int c,int flag)
{
    if(r<=L||l>=R) return ;
    if(L<=l&&r<=R)
    {
        lazy[i]+=c;
        pushUp(i,l,r,flag);
        return;
    }
    int mid=(l+r)>>1;
    update(lson,L,R,c,flag);
    update(i<<1|1,mid,r,L,R,c,flag);//建的树不一样
    pushUp(i,l,r,flag);
}
int main()
{
    //freopen("test.txt","r",stdin);
    int n,ii=1;
    while(~scanf("%d",&n))
    {
        int i,x1,y1,x2,y2,ans=0;
        mem(len,0);mem(lazy,0);
        for(i=0;i<n;i++)
        {
            scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
            int l=i<<1,r=i<<1|1;
            y[l]=y1,a[l].x=x1,a[l].y1=y1,a[l].y2=y2,a[l].flag=1;
            y[r]=y2,a[r].x=x2,a[r].y1=y1,a[r].y2=y2,a[r].flag=-1;
            x[l]=x1,b[l].x=y1,b[l].y1=x1,b[l].y2=x2,b[l].flag=1;
            x[r]=x2,b[r].x=y2,b[r].y1=x1,b[r].y2=x2,b[r].flag=-1;
        }
        sort(y,y+n*2); //因为是浮点数,而且数又大，不好建树
        int nn=unique(y,y+n*2)-y;//所以离散化了再建树
        sort(a,a+n*2,cmp);
        int parent=0;
        for(i=0;i<n*2;i++)
        {
            int l=lower_bound(y,y+nn,a[i].y1)-y+1;
            int r=lower_bound(y,y+nn,a[i].y2)-y+1;
            update(1,1,nn,l,r,a[i].flag,1);
            ans+=abs(len[1]-parent);
            parent=len[1];
        }

        mem(len,0);mem(lazy,0);
        sort(x,x+n*2); //因为是浮点数,而且数又大，不好建树
        nn=unique(x,x+n*2)-x;//所以离散化了再建树
        sort(b,b+n*2,cmp);
        parent=0;
        for(i=0;i<n*2;i++)
        {
            int l=lower_bound(x,x+nn,b[i].y1)-x+1;
            int r=lower_bound(x,x+nn,b[i].y2)-x+1;
            update(1,1,nn,l,r,b[i].flag,0);
            ans+=abs(len[1]-parent);
            parent=len[1];
        }
        printf("%d\n",ans);
    }
    return 0;
}

第十二道：

POJ 2828 逆序查找空位插入法

思路：线段树单点更新查找空位插入。

不理解的可以看这个网址的解释：http://www.cnblogs.com/CheeseZH/archive/2012/04/29/2476134.html

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
#include<cmath>
#include<bitset>
#define mem(a,b) memset(a,b,sizeof(a))
#define lson i<<1,l,mid
#define rson i<<1|1,mid+1,r
#define INF 510010
#define maxn 400010
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int sum[maxn*4],p[maxn],val[maxn],a[maxn],id;
void build(int i,int l,int r)
{
    sum[i]=r-l+1;
    if(l==r) return ;
    int mid=(l+r)>>1;
    build(lson);build(rson);
}
void update(int i,int l,int r,int v)
{
    sum[i]--;
    if(l==r) {id=l;return;}
    int mid=(l+r)>>1;
    if(v>sum[i<<1])
    {
        v-=sum[i<<1];
        update(rson,v);
    }
    else update(lson,v);
}
int main()
{
    int n,i;
    while(~scanf("%d",&n))
    {
        build(1,1,n);
        for(i=1;i<=n;i++)
            scanf("%d%d",p+i,val+i);
        for(i=n;i>0;i--)
        {
            update(1,1,n,p[i]+1);
            a[id]=val[i];
        }
        printf("%d",a[1]);
        for(i=2;i<=n;i++)
            printf(" %d",a[i]);
        puts("");
    }
    return 0;
}

第十三道：

POJ 2155  二维线段树

思路：二维线段树就是每个节点套一棵线段树的树。

刚开始因为题目是求A[I,J]，然后在y查询那直接ans^=Map[i][j]的时候没看懂，后面自己把图画出来了才理解。

因为只有0和1，所以可以用异或来搞，而不需要每次都需要修改。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
#include<cmath>
#include<bitset>
#define mem(a,b) memset(a,b,sizeof(a))
#define lson i<<1,l,mid
#define rson i<<1|1,mid+1,r
#define llson j<<1,l,mid
#define rrson j<<1|1,mid+1,r
#define INF 510010
#define maxn 4010
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
bool Map[maxn][maxn];
int n,q,t,ans;
void update_y(int i,int j,int l,int r,int y1,int y2)
{
    if(l==y1&&r==y2) {Map[i][j]^=1;return ;}
    int mid=(l+r)>>1;
    if(y2<=mid) update_y(i,llson,y1,y2);
    else if(y1>mid) update_y(i,rrson,y1,y2);
    else
    {
        update_y(i,llson,y1,mid);
        update_y(i,rrson,mid+1,y2);
    }
}
void update_x(int i,int l,int r,int x1,int x2,int y1,int y2)
{
    if(l==x1&&r==x2)
    {
        update_y(i,1,1,n,y1,y2);
        return ;
    }
    int mid=(l+r)>>1;
    if(x2<=mid) update_x(lson,x1,x2,y1,y2);
    else if(x1>mid) update_x(rson,x1,x2,y1,y2);
    else
    {
        update_x(lson,x1,mid,y1,y2);
        update_x(rson,mid+1,x2,y1,y2);
    }
}
void query_y(int i,int j,int l,int r,int y)
{
    ans^=Map[i][j];
    if(l==r) return ;
    int mid=(l+r)>>1;
    if(y<=mid) query_y(i,llson,y);
    else query_y(i,rrson,y);
}
void query_x(int i,int l,int r,int x,int y)
{
    query_y(i,1,1,n,y);
    if(l==r) return ;
    int mid=(l+r)>>1;
    if(x<=mid) query_x(lson,x,y);
    else query_x(rson,x,y);
}
int main()
{
    //freopen("test.txt","r",stdin);
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&q);
        mem(Map,0);
        while(q--)
        {
            char s[2];
            scanf("%s",s);
            ans=0;
            if(s[0]=='C')
            {
                int x1,x2,y1,y2;
                scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
                update_x(1,1,n,x1,x2,y1,y2);
            }
            else
            {
                int x,y;
                scanf("%d%d",&x,&y);
                query_x(1,1,n,x,y);
                printf("%d\n",ans);
            }
        }
        if(t) puts("");
    }
    return 0;
}

第十四道：

ZOJ 2859 二维线段树

思路：自己写的第二发二维线段树1A，哈哈，看来对二维的push操作比较了解了；但是还没遇到在两个线段树中同时进行push操作的，其实这题我是想在x维和y维同时进行push操作的，但是想了好久不会，然后看到这题又给出10秒，然后想想在x维线段直接单点查询肯定也过了，然后就只有pushup操作，没有lazy延时pushdown操作。不过也A了，想找题即在二维同时进行pushup和pushdown操作的。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
#include<cmath>
#include<bitset>
#define mem(a,b) memset(a,b,sizeof(a))
#define lson i<<1,l,mid
#define rson i<<1|1,mid+1,r
#define llson j<<1,l,mid
#define rrson j<<1|1,mid+1,r
#define INF 0x7fffffff
#define maxn 1010
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int Map[maxn][maxn],Min[maxn][maxn];
int n,q,t,ans;
void pushup(int i,int j)
{
    Min[i][j]=min(Min[i][j<<1],Min[i][j<<1|1]);
}
void build_y(int i,int u,int j,int l,int r)
{
    if(l==r)
    {
        Min[i][j]=Map[u][l];
        return ;
    }
    int mid=(l+r)>>1;
    build_y(i,u,llson);build_y(i,u,rrson);
    pushup(i,j);
}
void build_x(int i,int l,int r)
{
    if(l==r)
    {
        build_y(i,l,1,1,n);
        return ;
    }
    int mid=(l+r)>>1;
    build_x(lson);build_x(rson);
}
int query_y(int i,int j,int l,int r,int y1,int y2)
{
    if(l==y1&&y2==r) return Min[i][j];
    int mid=(l+r)>>1;
    if(y2<=mid) return query_y(i,llson,y1,y2);
    else if(y1>mid) return query_y(i,rrson,y1,y2);
    else return min(query_y(i,llson,y1,mid),query_y(i,rrson,mid+1,y2));
}
void query_x(int i,int l,int r,int x1,int x2,int y1,int y2)
{
    if(l==r)
    {
        ans=min(ans,query_y(i,1,1,n,y1,y2));
        return ;
    }
    int mid=(l+r)>>1;
    if(x1<=mid) query_x(lson,x1,x2,y1,y2);
    if(x2>mid) query_x(rson,x1,x2,y1,y2);
}
int main()
{
    freopen("test.txt","r",stdin);
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                scanf("%d",&Map[i][j]);
        build_x(1,1,n);
        scanf("%d",&q);
        while(q--)
        {
            int x1,y1,x2,y2;
            ans=INF;
            scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
            query_x(1,1,n,x1,x2,y1,y2);
            printf("%d\n",ans);
        }
    }
    return 0;
}

HDU 4614

思路：把区间空的地方记录下来求和，然后1的时候求1到a-1的0个数为cnt，查询cnt+1的位置就是第一个位置，查询cnt+b的位置就是最后一个位置；2的时候直接查询，然后再更新。

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
#include<set>
#include<cmath>
#include<bitset>
#include<time.h>
#define mem(a,b) memset(a,b,sizeof(a))
#define lson i<<1,l,mid
#define rson i<<1|1,mid+1,r
#define llson j<<1,l,mid
#define rrson j<<1|1,mid+1,r
#define INF 0x7fffffff
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
#define maxn 1000005
int sum[maxn],lazy[maxn];
void build(int i,int l,int r)
{
    sum[i]=r-l+1,lazy[i]=0;
    if(l==r) return ;
    int mid=(l+r)>>1;
    build(lson),build(rson);
}
void pushDown(int i,int l,int r)
{
    if(lazy[i]&&l!=r)
    {
        if(lazy[i]==-1) sum[i<<1]=sum[i<<1|1]=0;
        else
        {
            sum[i<<1]=((r-l)>>1)+1;
            sum[i<<1|1]=(r-l+1)>>1;
        }
        lazy[i<<1]=lazy[i<<1|1]=lazy[i];
        lazy[i]=0;
    }
}
void pushUp(int i)
{
    sum[i]=sum[i<<1]+sum[i<<1|1];
}
void update(int i,int l,int r,int L,int R,int val)
{
    if(L<=l&&r<=R)
    {
        if(val==-1) sum[i]=0;
        else sum[i]=r-l+1;
        lazy[i]=val;
        return ;
    }
    pushDown(i,l,r);
    int mid=(l+r)>>1;
    if(R<=mid) update(lson,L,R,val);
    else if(L>mid) update(rson,L,R,val);
    else
    {
        update(lson,L,mid,val);
        update(rson,mid+1,R,val);
    }
    pushUp(i);
}
int query(int i,int l,int r,int L,int R)
{
    if(L<=l&&r<=R) return sum[i];
    int mid=(l+r)>>1,ans=0;
    pushDown(i,l,r);
    if(R<=mid) ans=query(lson,L,R);
    else if(L>mid) ans=query(rson,L,R);
    else ans=query(lson,L,mid)+query(rson,mid+1,R);
    pushUp(i);
    return ans;
}
int findPos(int i,int l,int r,int L,int R,int val)
{
    if(l==r) return l;
    int mid=(l+r)>>1,pos=0;
    pushDown(i,l,r);
    if(R<=mid) pos=findPos(lson,L,R,val);
    else if(L>mid) pos=findPos(rson,L,R,val);
    else
    {
        if(sum[i<<1]>=val) pos=findPos(lson,L,mid,val);
        else pos=findPos(rson,mid+1,R,val-sum[i<<1]);
    }
    pushUp(i);
    return pos;
}
int main()
{
    //freopen("1.txt","r",stdin);
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n,m,q,a,b;
        scanf("%d%d",&n,&m);
        build(1,1,n);
        while(m--)
        {
            scanf("%d%d%d",&q,&a,&b);
            if(q==1)
            {
                a++;
                int tmp=query(1,1,n,a,n);
                if(!tmp)
                {
                    puts("Can not put any one.");
                    continue;
                }
                if(tmp<b) b=tmp;
                int sum1=0;
                if(a-1>=1) sum1=query(1,1,n,1,a-1);
                int pos1=findPos(1,1,n,1,n,sum1+1);
                int pos2=findPos(1,1,n,1,n,sum1+b);
                update(1,1,n,pos1,pos2,-1);
                printf("%d %d\n",pos1-1,pos2-1);
            }
            else
            {
                a++,b++;
                int sum1=query(1,1,n,a,b);
                update(1,1,n,a,b,1);
                printf("%d\n",b-a+1-sum1);
            }
        }
        puts("");
    }
    return 0;
}