线段树kuangbin专题

先来一个通用的模板（好像用x * 2 不如用 x >> 1 , x * 2 + 1 不如用 x >> 1 | 1 呢，位运算很厉害的，慢慢习惯吧）

typedef long long ll;
const int maxn = 2e5 + 10;
struct node
{
    ll minn,maxx,sum,f,c;   //f是加法标记，c是乘法标记
}tree[4 * maxn];   //结构体开4倍空间
ll n,a[maxn],m,p;
ll x,y,s,op;

void build(int x,int l,int r)  //建树  build(1,1,n);
{
    if(l == r)
    {
        tree[x].sum = a[l];
        //tree[x].maxx = a[l];
        //tree[x].minn = a[l];
        tree[x].c = 1;  
        return;
    }
    int mid = (l + r) / 2;
    build(x * 2,l,mid);
    build(x * 2 + 1,mid + 1,r);
    //tree[x].maxx = max(tree[x * 2].maxx,tree[x * 2 + 1].maxx);
    //tree[x].minn = max(tree[x * 2].minn,tree[x * 2 + 1].minn);
    tree[x].sum = (tree[x * 2].sum + tree[x * 2 + 1].sum) % p;
}

void down(int x,int l,int r)    //懒惰标记
{
    int mid = (l + r) / 2;
    tree[x * 2].f += tree[x].f;
    tree[x * 2 + 1].f += tree[x].f;
    tree[x * 2].sum += tree[x].f * (mid - l + 1);
    tree[x * 2 + 1].sum += tree[x].f * (r - mid);
    //tree[x * 2].maxx += tree[x].f;
    //tree[x * 2 + 1].maxx += tree[x].f;
    //tree[x * 2].minn += tree[x].f;
    //tree[x * 2 + 1].minn += tree[x].f;
    tree[x].f = 0;
}

void add1(int x,int l,int r,int pos,int s)   //单点修改  add(1,1,n,x,s)
{
    if(l == r)
    {
        tree[x].sum += s;
        //tree[x].maxx += s;
        //tree[x].minn += s;
        return;
    }
    if(tree[x].f) down(x,l,r);
    int mid = (l + r) / 2;
    if(pos <= mid) add1(x * 2,l,mid,pos,s);
    else add1(x * 2 + 1,mid + 1,r,pos,s);
    //tree[x].maxx = max(tree[x * 2].maxx,tree[x * 2 + 1].maxx);
    //tree[x].minn = max(tree[x * 2].minn,tree[x * 2 + 1].minn);
    tree[x].sum = tree[x * 2].sum + tree[x * 2 + 1].sum;
}

ll query(int x,int l,int r,int pos)   //单点查询   query(1,1,n,x);
{
    if(l == r) return tree[x].maxx;
    if(tree[x].f) down(x,l,r);
    int mid = (l + r) / 2;
    if(pos <= mid) return query(x * 2,l,mid,pos);
    else query(x * 2 + 1,mid + 1,r,pos);
}

void add2(int x,int l,int r,int al,int ar,int s)   //区间修改   add2(1,1,n,l,r,s);
{
    if(l >= al && r <= ar)
    {
        tree[x].sum = (tree[x].sum + (r - l + 1) * s) % p; //(r-1)+1区间点的总数
        //tree[x].maxx += s;
        //tree[x].minn += s;
        tree[x].f += s;
        return;
    }
    if(tree[x].f) down(x,l,r);
    int mid = (l + r) / 2;
    if(al <= mid) add2(x * 2,l,mid,al,ar,s);
    if(ar > mid) add2(x * 2 + 1,mid + 1,r,al,ar,s);
    //tree[x].maxx = max(tree[x * 2].maxx,tree[x * 2 + 1].maxx);
    //tree[x].minn = max(tree[x * 2].minn,tree[x * 2 + 1].minn);
    tree[x].sum = (tree[x * 2].sum + tree[x * 2 + 1].sum) % p;
}

ll query2(int x,int l,int r,int al,int ar)
{
    if(l >= al && r <= ar) return tree[x].sum; 
    //if(l >= al && r <= ar) return tree[x].maxx;
    //if(l >= al && r <= ar) return tree[x].minn;
    if(tree[x].f) down(x,l,r);
    int mid = (l + r) / 2;
    if(ar <= mid) return query2(x * 2,l,mid,al,ar);
    else if(al > mid) return query2(x * 2 + 1,mid + 1,r,al,ar);
    else return query2(x * 2,l,mid,al,ar) + query2(x * 2 + 1,mid + 1,r,al,ar);   //求和
    // else return max(query2(x * 2,l,mid,al,ar),query2(x * 2 + 1,mid + 1,r,al,ar));
    // else return min(query2(x * 2,l,mid,al,ar),query2(x * 2 + 1,mid + 1,r,al,ar));
}

解决一些模板题还是问题不大滴，但是稍微灵活一些的就需要开动脑筋了

POJ 2528

题目：线段覆盖问题，后来的可以覆盖之前的线段，问到最后有多少线段没有被完全覆盖

解：这题需要用到离散化来将数据映射到一段很小的范围以大幅减少时间空间复杂度（以前很少写离散化正好学习一下）

#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;

const int maxn = 1e6 + 10;
int T,ans,tot,n;
int tree[maxn],a[maxn],l[maxn],r[maxn];
bool h[maxn];

void add(int x,int l,int r,int al,int ar,int c)
{
    if(al <= l && ar >= r)
    {
        //printf("%d %d\n",l,r);
        tree[x] = c;
        return;
    }
    if(tree[x] != -1)
    {
        tree[x << 1] = tree[x << 1 | 1] = tree[x];
        tree[x] = -1;
    }
    int mid = (l + r) / 2;
    if(al <= mid) add(x << 1,l,mid,al,ar,c);
    if(ar > mid) add(x << 1 | 1,mid + 1,r,al,ar,c);
}

void query(int x,int l,int r)
{
    if(l == r)
    {
        if(tree[x] != -1 && !h[tree[x]])
            ans++,h[tree[x]] = 1;
        return;
    }
    if(tree[x] != -1)
    {
        tree[x << 1] = tree[x << 1 | 1] = tree[x];
        tree[x] = -1;
    }
    int mid = (l + r) / 2;
    query(x << 1,l,mid);
    query(x << 1 | 1,mid + 1,r);
}

int main()
{
    scanf("%d",&T);
    while(T--)
    {
        memset(tree,-1,sizeof(tree));
        memset(h,0,sizeof(h));
        scanf("%d",&n);
        tot = 0;
        for(int i = 1;i <= n; ++i)
        {
            scanf("%d%d",&l[i],&r[i]);
            a[++tot] = l[i];
            a[++tot] = r[i];
        }
        sort(a + 1,a + tot + 1);
        int k = 1;
        for(int i = 2;i <= tot; ++i)
            if(a[i] != a[i - 1]) a[++k] = a[i];
        tot = k;
        for(int i = 2;i <= k; ++i)
            if(a[i] != a[i - 1] + 1) a[++tot] = a[i] - 1;
        sort(a + 1,a + tot + 1);
        for(int i = 1;i <= n; ++i)
        {
            int x = lower_bound(a + 1,a + tot + 1,l[i]) - a;
            int y = lower_bound(a + 1,a + tot + 1,r[i]) - a;
            add(1,1,tot,x,y,i);
        }
        ans = 0;
        query(1,1,tot);
        printf("%d\n",ans);
    }
    return 0;
}

codevs 

4919 线段树练习4

题目描述 Description

给你N个数，有两种操作

1：给区间[a,b]内的所有数都增加X

2：询问区间[a,b]能被7整除的个数

输入描述 Input Description

第一行一个正整数n，接下来n行n个整数，再接下来一个正整数Q，表示操作的个数. 接下来Q行每行若干个整数。如果第一个数是add，后接3个正整数a,b,X，表示在区间[a,b]内每个数增加X,如果是count，表示统计区间[a,b]能被7整除的个数

输出描述 Output Description

对于每个询问输出一行一个答案

样例输入 Sample Input

 3 

2 3 4

6

count 1 3

count 1 2

add 1 3 2

count 1 3

add 1 3 3

count 1 3

样例输出 Sample Output

0

0

0

1

数据范围及提示 Data Size & Hint

10%:1<N<=10,1<Q<=10

30%:1<N<=10000,1<Q<=10000

100%:1<N<=100000,1<Q<=100000

 

解：刚开始看到这个题是极度蒙蔽的，翻了篇博客明白大体思路就自己敲，可能是上传下传标记的问题疯狂WA

其实就是用线段树存储下mod 7 = 0/1/2/3/4/5/6的数字个数

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
using namespace std;

const int maxn = 1e6 + 10;
struct node
{
    int mod[7],f;
}tree[maxn];
int n,m,a[maxn],x,y,z;
string s;

void up(int x)   
{
    for(int i = 0;i < 7; ++i)
        tree[x].mod[i] = tree[x << 1].mod[i] + tree[x << 1 | 1].mod[i];
}

void wadd(int x,int s)  //更新mod 7 后的数值个数
{
    for(int i = 0;i < 7; ++i) a[i] = tree[x].mod[i];
    for(int i = 0;i < 7; ++i) tree[x].mod[(i + s) % 7] = a[i];
}

void build(int x,int l,int r)
{
    for(int i = 0;i < 7; ++i) tree[x].mod[i] = 0;
    tree[x].f = 0;
    if(l == r)
    {
        tree[x].mod[a[l] % 7] = 1;
        return;
    }
    int mid = (l + r) / 2;
    build(x << 1,l,mid);
    build(x << 1 | 1,mid + 1,r);
    up(x);
}

void down(int x,int l,int r)
{
    wadd(x << 1,tree[x].f);
    wadd(x << 1 | 1,tree[x].f);
    tree[x << 1].f += tree[x].f;
    tree[x << 1 | 1].f += tree[x].f;
    tree[x].f = 0;
}

void add(int x,int l,int r,int al,int ar,int s)
{
    if(l >= al && r <= ar)
    {
        tree[x].f += s;
        wadd(x,s);
        return;
    }
    if(tree[x].f) down(x,l,r);
    int mid = (l + r) / 2;
    if(al <= mid) add(x << 1,l,mid,al,ar,s);
    if(ar > mid) add(x << 1 | 1,mid + 1,r,al,ar,s);
    up(x);
 }

int query(int x,int l,int r,int al,int ar)
{
    if(l >= al && r <= ar) return tree[x].mod[0];
    if(tree[x].f) down(x,l,r);
    int mid = (l + r) / 2;
    if(ar <= mid) return query(x << 1,l,mid,al,ar);
    else if(al > mid) return query(x << 1 | 1,mid + 1,r,al,ar);
    else return query(x << 1,l,mid,al,ar) + query(x << 1 | 1,mid + 1,r,al,ar);
}

int main()
{
    scanf("%d",&n);
    for(int i = 1;i <= n; ++i) scanf("%d",&a[i]);
    build(1,1,n);   //建树
    scanf("%d",&m);
    for(int i = 0;i < m; ++i)
    {
        cin>>s;
        scanf("%d%d",&x,&y);
        if(s[0] == 'c')  printf("%d\n",query(1,1,n,x,y));
        if(s[0] == 'a')
        {
            scanf("%d",&z);
            add(1,1,n,x,y,z % 7);
        }
    }
    return 0;
}

ZOJ - 1610

线段覆盖，最后问有多少连续的线段

#include<bits/stdc++.h>
using namespace  std;

const int maxn = 1e4 + 10;
int tree[4 * maxn];
int n,x,y,z,last;
map<int,int>q;

void build(int x,int l,int r)
{
    tree[x] = -1;
    if(l == r) return;
    int mid = (l + r) / 2;
    build(x << 1,l,mid);
    build(x << 1 | 1,mid + 1,r);
}

void down(int x,int l,int r)   //标记下传
{
    tree[x << 1] = tree[x << 1 | 1] = tree[x];
    tree[x] = -1;
}

void add(int x,int l,int r,int al,int ar,int c)
{
    if(l >= al && r <= ar)
    {
        tree[x] = c;
        return;
    }
    if(tree[x] != -1) down(x,l,r);
    int mid = (l + r) / 2;
    if(al <= mid) add(x << 1,l,mid,al,ar,c);
    if(ar > mid) add(x << 1 | 1,mid + 1,r,al,ar,c);
}

void query(int x,int l,int r)
{
    if(l == r)
    {
        if(tree[x] != -1 && last != tree[x])
            q[tree[x]]++;
        last = tree[x];   //询问连续段，一定要注意这个操作，因为这里不对WA了好久
        return;
    }
    if(tree[x] != -1) down(x,l,r);
    int mid = (l + r) / 2;
    query(x << 1,l,mid);
    query(x << 1 | 1,mid + 1,r);
}

int main()
{
    while(~scanf("%d",&n))
    {
        q.clear();
        build(1,0,8000);   //其实可以不建树，建树的目的是将tree数组初始化为-1
        for(int i = 0;i < n; ++i)
        {
            scanf("%d%d%d",&x,&y,&z);
            add(1,0,8000,x + 1,y,z);   //覆盖的是线段而不是点
        }
        last = -1;
        query(1,0,8000);   //查询
        for(int i = 0;i < 8001; ++i)
            if(q[i]) printf("%d %d\n",i,q[i]);
        printf("\n");
    }
    return 0;
}

HDU - 4027

题目：n个整数，操作分为区间求和和把某一个区间内的数字变成她的平方根

解：正常写线段树，区间修改时要注意修改到l==r，对了还有个优化，要是这个区间里的数字都是1，就没有必要再开根了，事实证明，这样做是十分有效的，因为就算是一个2^63级别的数字，也只需要开不超过10次就到了1，所以后面的开根操作可以无视

#include<cstdio>
#include<algorithm>
using namespace std;

typedef long long ll;
const int maxn = 2e5 + 10;
ll tree[4 * maxn],a[maxn];
int n,m,t,x,y;

void build(int x,int l,int r)
{
    if(l == r)
    {
        tree[x] = a[l];
        return;
    }
    int mid = (l + r) / 2;
    build(x << 1,l,mid);
    build(x << 1 | 1,mid + 1,r);
    tree[x] = tree[x << 1] + tree[x << 1 | 1];
}

void change(int x,int l,int r,int al,int ar)
{
    if(l == r)
    {
        if(l >= al && r <= ar) tree[x] = sqrt(tree[x]);
        return;
    }
    if(l >= al && r <= ar && tree[x] == r - l + 1) return;
    //如果这个区间里的数字都是1，不需要再修改
    int mid = (l + r) / 2;
    if(al <= mid) change(x << 1,l,mid,al,ar);
    if(ar > mid) change(x << 1 | 1,mid + 1,r,al,ar);
    tree[x] = tree[x << 1] + tree[x << 1 | 1];
}

ll query(int x,int l,int r,int al,int ar)
{
    if(l >= al && r <= ar) return tree[x];
    int mid = (l + r) / 2;
    if(ar <= mid) return query(x << 1,l,mid,al,ar);
    else if(al > mid) return query(x << 1 | 1,mid + 1,r,al,ar);
    else return query(x << 1,l,mid,al,ar) + query(x << 1 | 1,mid + 1,r,al,ar);
}

int main()
{
    int tot = 0;
    while(~scanf("%d",&n))
    {
        for(int i = 1;i <= n; ++i)
            scanf("%lld",&a[i]);
        build(1,1,n);
        scanf("%d",&m);
        printf("Case #%d:\n",++tot);
        for(int i = 0;i < m; ++i)
        {
            scanf("%d%d%d",&t,&x,&y);
            if(x > y) swap(x,y); //有x>y的数据，好坑hhh
            if(t) printf("%lld\n",query(1,1,n,x,y));
            else change(1,1,n,x,y);
        }
        printf("\n");
    }
    return 0;
}

POJ 2892

题意是一条线上的点，D x是破坏这个点，Q x是表示查询以x所在的最长的连续的点的个数，R是恢复上一次破坏的点

其实就是维护最长连续子区间的操作，代码已经解释的很仔细啦

#include<cstdio>
#include<iostream>
using namespace std;

const int maxn = 1e5 + 10;
int n,m,x;
int s[maxn],top;
char ch;

struct node
{
    int ls,rs,ms;///ls,左端最大连续区间，rs右端最大连续区间，ms区间内最大连续区间
} a[maxn << 2];

void build(int x,int l,int r)
{
    a[x].ls = a[x].rs = a[x].ms = r - l + 1;
    if(l == r) return;
    int mid = (l + r) >> 1;
    build(x << 1,l,mid);
    build(x << 1 | 1,mid + 1,r);
}

void add(int x,int l,int r,int t,int xi)
{
    if(l == r)
    {
        if(xi) a[x].ls = a[x].rs = a[x].ms = 1;///修复
        else a[x].ls = a[x].rs = a[x].ms = 0;///破坏
        return ;
    }
    int mid = (l + r) >> 1;
    if(t <= mid) add(x << 1,l,mid,t,xi);
    else add(x << 1 | 1,mid + 1,r,t,xi);
    a[x].ls = a[x << 1].ls;///左区间
    a[x].rs = a[x << 1 | 1].rs;///右区间
    a[x].ms = max(max(a[x << 1].ms,a[x << 1 | 1].ms),
                  a[x << 1].rs + a[x << 1 | 1].ls);
    /**父亲区间内的最大区间必定是，
      左子树最大区间，右子树最大区间，
      左右子树合并的中间区间，三者中最大的区间值
    */
    if(a[x << 1].ls == mid - l + 1) a[x].ls += a[x << 1 | 1].ls;
        ///左子树区间满了的话，父亲左区间要加上右孩子的左区间
    if(a[x << 1 | 1].rs == r - mid) a[x].rs += a[x << 1].rs;
        ///右子树区间满了的话，父亲右区间要加上左孩子的右区间
}

int query(int x,int l,int r,int t)
{
    if(l == r || a[x].ms == 0 || a[x].ms == r - l + 1) return a[x].ms;
    ///到了叶子节点或者该访问区间为空或者已满都不必往下走
    int mid = (l + r) >> 1;
    if(t <= mid)
    {
        if(t >= mid - a[x << 1].rs + 1)
            return query(x << 1,l,mid,t) + query(x << 1 | 1,mid + 1,r,mid + 1);
        /**
        因为t <= mid，看左子树，
        a[x << 1].r - a[x << 1].rs + 1代表左子树右边连续区间的左边界值，
        如果t在左子树的右区间内，则要看右子树的左区间有多长并返回
        */
        else return query(x << 1,l,mid,t);
    ///如果不在左子树的右边界区间内，则只需要看左子树
    }
    else
    {
        if(t <= mid + a[x << 1 | 1].ls)
            return query(x << 1 | 1,mid + 1,r,t) + query(x << 1,l,mid,mid);
        else return query(x << 1 | 1,mid + 1,r,t);
    }
}

int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        top = 0;
        build(1,1,n);
        while(m--)
        {
            cin>>ch;
            if(ch == 'D')
            {
                scanf("%d",&x);
                s[top++] = x;
                add(1,1,n,x,0);
            }
            else if(ch == 'Q')
                scanf("%d",&x),printf("%d\n",query(1,1,n,x));
            else x = s[--top],add(1,1,n,x,1);
        }
    }
    return 0;
}