线段树

参考博客：
基本线段树模板（建树、点/区间修改、查询）

题目：P3372 【模板】线段树 1

代码：

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

const int maxn = 1e5+10;
#define LL long long
LL a[maxn<<2], st[maxn<<2], add[maxn<<2];
void build(LL o, LL l, LL r){
     if(l == r)st[o] = a[l];
     else {
        LL m = l + ((r-l)>>1);
        build(o<<1, l, m);
        build(o<<1|1, m+1, r);
        st[o] = st[o<<1] + st[o<<1|1];
     }
}

void pushup(LL o){
     st[o] = st[o<<1] + st[o<<1|1];
}
void pushdown(LL o, LL l, LL r){
     if(add[o]){
        add[o<<1] += add[o];
        add[o<<1|1] += add[o];
        LL m = l + ((r-l)>>1);
        st[o<<1] += add[o]*(m-l+1);
        st[o<<1|1] += add[o]*(r-m);
        add[o] = 0;
     }
}
void update(LL o, LL l, LL r, LL ql, LL qr, LL addv){
     if(ql <= l && qr >= r){
        add[o] += addv;
        st[o] += addv*(r-l+1);
        return;
     }
     pushdown(o, l, r);
     LL m = l + ((r-l)>>1);
     if(ql <= m)update(o<<1, l, m, ql, qr, addv);
     if(qr >= m+1)update(o<<1|1, m+1, r, ql, qr, addv);
     pushup(o);
}
LL query(LL o, LL l, LL r, LL ql, LL qr){
    if(ql<= l && qr >= r)return st[o];
    pushdown(o, l, r);
    LL m = l + ((r-l)>>1);
    LL ans = 0;
    if(ql <= m)ans += query(o<<1, l, m, ql, qr);
    if(qr >= m+1)ans += query(o<<1|1, m+1, r, ql, qr);
    return ans;
}
int main(){
    LL n, m;
    scanf("%lld %lld", &n, &m);
    for(LL i = 1; i <= n; i++)scanf("%lld", &a[i]);
    build(1, 1, n);
    while(m--){
        LL a, b, c, d;
        scanf("%lld", &a);
        if(a == 1){
            scanf("%lld %lld %lld", &b, &c, &d);
            update(1,1, n, b, c, d);
        }
        else {
            scanf("%lld %lld", &b, &c);
            printf("%lld\n", query(1,1, n,  b, c));
        }

    }
return 0;
}

题目:P3373 【模板】线段树 2

代码：

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

const int maxn = 1e5+10;
#define LL long long
LL a[maxn<<2], st[maxn<<2], add[maxn<<2], mul[maxn<<2];
LL mod;
void build(LL o, LL l, LL r)
{
    mul[o] = 1;
    add[o] = 0;
    if(l == r)st[o] = a[l];
    else
    {
        LL m = l + ((r-l)>>1);
        build(o<<1, l, m);
        build(o<<1|1, m+1, r);
        st[o] = (st[o<<1]+st[o<<1|1]) % mod;
    }
}

void pushup(LL o)
{
    st[o] = (st[o<<1] + st[o<<1|1]) % mod;
}
void pushdown(LL o, LL l, LL r)
{
    LL m = l + ((r-l)>>1);
    st[o<<1] = (st[o<<1]*mul[o]+add[o]*(m-l+1))%mod;
    st[o<<1|1] = (st[o<<1|1]*mul[o]+add[o]*(r-m))%mod;
    mul[o<<1] = (mul[o]*mul[o<<1])%mod;
    mul[o<<1|1] = (mul[o<<1|1]*mul[o])%mod;
    add[o<<1] = (add[o<<1]*mul[o]+add[o])%mod;
    add[o<<1|1] = (add[o<<1|1]*mul[o] + add[o])%mod;
    add[o] = 0;
    mul[o] = 1;
    return;
    //}
}


void update(LL o, LL l, LL r, LL ql, LL qr, LL addv)
{

    if(ql <= l && qr >= r)
    {
        add[o] =(add[o] + addv) % mod;
        st[o] =(st[o] + addv*(r-l+1))%mod;
        return;
    }
    pushdown(o, l, r);
    LL m = l + ((r-l)>>1);
    if(ql <= m)update(o<<1, l, m, ql, qr, addv);
    if(qr >= m+1)update(o<<1|1, m+1, r, ql, qr, addv);
    pushup(o);
    return;
}
void update1(LL o, LL l, LL r, LL ql, LL qr, LL addv)
{

    if(ql <= l && qr >= r)
    {
        add[o] = (add[o]*addv)%mod;
        mul[o] = (mul[o]*addv)%mod;
        st[o] = (st[o]*addv)%mod;
        return;
    }
    pushdown(o, l, r);
    LL m = l + ((r-l)>>1);
    if(ql <= m)update1(o<<1, l, m, ql, qr, addv);
    if(qr >= m+1)update1(o<<1|1, m+1, r, ql, qr, addv);
    pushup(o);
    return;
}
LL query(LL o, LL l, LL r, LL ql, LL qr)
{
    LL ans = 0;
    if(ql<= l && qr >= r)return st[o];
    pushdown(o, l, r);
    LL m = (l + r)>>1 ;
    if(ql <= m)ans = (ans + query(o<<1, l, m, ql, qr))%mod;
    if(qr >= m+1)ans = (ans + query(o<<1|1, m+1, r, ql, qr)) % mod;
    return ans;
}
int main()
{
    LL n, m, x, y, z, op;
    scanf("%lld %lld %lld", &n, &m, &mod);
    for(LL i = 1; i <= n; i++)scanf("%lld", &a[i]);
    build(1, 1, n);
    while(m--)
    {
        scanf("%lld", &op);
        if(op == 1)
        {
            scanf("%lld %lld %lld", &x, &y, &z);
            update1(1, 1, n, x, y, z);
        }
        else if(op == 2)
        {
            scanf("%lld %lld %lld", &x, &y, &z);
            update(1, 1, n, x, y, z);
        }
        else if(op == 3)
        {
            scanf("%lld %lld", &x, &y);
            printf("%lld\n", query(1, 1, n, x, y));

        }
        else
        {
            for(int i = 1; i <= n; i++)
            {
                printf("%lld ", query(1, 1, n, i, i));
            }
            printf("\n");

        }

    }
}

题目：I Hate It

代码：

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

const int maxn = 200005;

int st[maxn<<2];

void build(int o, int l, int r)
{
    if(l == r)scanf("%d", &st[o]);
    else
    {
        int m = l + ((r-l)>>1);
        build(o<<1, l, m);
        build(o<<1|1, m+1, r);
        st[o] = max(st[o<<1], st[o<<1|1]);
    }
}
void update(int o, int l, int r, int ind, int ans)
{
    if(l == r)
    {
        st[o] = ans;
        return;
    }
    int m = l + ((r-l)>>1);
    if(ind <= m)update(o<<1, l, m, ind, ans);
    else update(o<<1|1, m+1, r, ind, ans);
    st[o] = max(st[o<<1], st[o<<1|1]);

}

int query(int o, int l, int r, int ql, int qr)
{
    if(ql > r || qr < l)return -1;
    if(ql <= l && qr >= r)return st[o];
    int m = l + ((r-l)>>1);
    int p1 = query(o<<1, l, m, ql, qr), p2 = query(o<<1|1, m+1, r, ql, qr);
    return max(p1, p2);
}
int main()
{
    int n, m, x, y, z;
    char op;
    while( ~scanf("%d %d", &n, &m))
    {

        build(1, 1, n);
        while(m--)
        {
            getchar();
            scanf("%c", &op);

            if(op == 'Q')
            {
                scanf("%d %d", &x, &y);
                printf("%d\n", query(1, 1, n, x, y));
            }
            else
            {
                scanf("%d %d", &x, &y);
                update(1, 1, n, x, y);
            }



        }
    }
}

题目：Mayor’s posters

题意：就是告诉你，有一面墙，墙的宽度是1e7,然后让你贴海报，海报的高度是跟墙的高度是一致的，每次粘贴海报会把之前的海报覆盖掉，问你最后能看见的海报有几张，只要这个海报没有完全被覆盖掉，那么这个海报就能露出来。
思路：本体的思路，因为涉及到区间修改，所以我就想到了线段树，线段树的区间修改。但是如何去查询海报剩下几张呢，我们把海报做成一个编号，每次的区间覆盖，我们就把这个区间的值赋值为这个海报的编号，然后通过一个数组去标记，然后统计有多少个数组已经被标记了。
但是存在一个问题，数据的大小太大了，但是数据的个数不大，所以很容易想到离散化，通过离散化把数据变得小一点。
代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;

const int maxn = 1e5+10;

int st[maxn<<2], add[maxn<<2];
struct Node
{
    int x, y;
} a[maxn];
int vis[maxn], b[maxn];
void build(int o, int l, int r)
{
    if(l == r)st[o] = 0;
    else
    {
        int m = l + ((r-l)>>1);
        build(o<<1, l, m);
        build(o<<1|1, m+1, r);
        st[o] = st[o<<1] + st[o<<1|1];
    }
}

void pushup(int o)
{
    st[o]=st[o<<1]+st[o<<1|1];
}

void pushdown(int o,int l,int r) //pushdown和区间加值不同，改值时修改结点信息只需要对修改后的信息求和即可，不用加上原信息
{
    if(add[o])
    {
        int c=add[o];
        add[o<<1]=c;
        add[o<<1|1]=c;
        int m=l+((r-l)>>1);
        st[o<<1]=(m-l+1)*c;
        st[o<<1|1]=(r-m)*c;
        add[o]=0;
    }
}

void update(int o,int l,int r,int ql,int qr,int c)
{
    if(ql<=l&&qr>=r) //同样更新结点信息和区间加值不同
    {
        add[o]=c;
        st[o]=(r-l+1)*c;
        return;
    }
    pushdown(o,l,r);
    int m=l+((r-l)>>1);
    if(ql<=m)update(o<<1,l,m,ql,qr,c);
    if(qr>=m+1)update(o<<1|1,m+1,r,ql,qr,c);
    pushup(o);
}

int query(int o,int l,int r,int ql,int qr)
{
    if(ql<=l&&qr>=r) return st[o];
    pushdown(o,l,r);
    int m=l+((r-l)>>1);
    int ans=0;
    if(ql<=m)ans+=query(o<<1,l,m,ql,qr);
    if(qr>=m+1)ans+=query(o<<1|1,m+1,r,ql,qr);
    return ans;
}
int main()
{
    int T, n;
    scanf("%d", &T);
    while(T--)
    {
        memset(vis, 0, sizeof(vis));
        scanf("%d", &n);
        int tot = 0;
        for(int i = 1; i <= n; i++)
        {
            scanf("%d %d", &a[i].x, &a[i].y);
            b[tot++] = a[i].x;
            b[tot++] = a[i].y;
        }
        sort(b, b+tot);
        for(int i = 1; i <= n; i++)
        {
            a[i].x = lower_bound(b,b+tot, a[i].x)-b+1;//离散化
            a[i].y = lower_bound(b,b+tot, a[i].y)-b+1;
        }

        build(1, 1, tot);
        for(int i = 1; i  <= n; i++)update(1, 1, tot, a[i].x, a[i].y, i);
        for(int i = 1; i <= tot; i++)
        {
            vis[query(1, 1, tot, i, i)] = 1;//标记
        }
        int cn = 0;
        for(int i = 1; i <= tot; i++)
        {
            if(vis[i])cn++;
        }
        printf("%d\n", cn);
    }
    return 0;
}

题目：Balanced Lineup

题意：本题的题意就是给你一个区间求区间的最大值和最小值的差值。
思路：建两个线段树，一个用来维护最大值，另外一个用来维护最小值。
代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
using namespace std;
const int INF = 2e5+10;

int st[INF<<2], b[INF<<2];
int tt[INF<<2], a[INF<<2];
const int maxn = 1e7;
void build(int o, int l, int r)
{
    if(l == r)st[o] = a[l];
    else
    {
        int m = l + ((r-l)>>1);
        build(o<<1, l, m);
        build(o<<1|1, m+1, r);
        st[o] = max(st[o<<1],st[o<<1|1]);
    }
}
void build1(int o, int l, int r)
{
    if(l == r)tt[o] = a[l];
    else
    {
        int m = l + ((r-l)>>1);
        build1(o<<1, l, m);
        build1(o<<1|1, m+1, r);
        tt[o] = min(tt[o<<1],tt[o<<1|1]);
    }
}
int query(int o,int l,int r,int ql,int qr)
{
    if(ql<=l&&qr>=r) return st[o];
    int m=l+((r-l)>>1);
    int ans1 = 0, ans2 = 0;
    if(ql<=m)ans1 = query(o<<1,l,m,ql,qr);
    if(qr>=m+1)ans2 = query(o<<1|1,m+1,r,ql,qr);
    return max(ans1, ans2);
}
int query1(int o,int l,int r,int ql,int qr)
{
    if(ql<=l&&qr>=r) return tt[o];
    int m=l+((r-l)>>1);
    int ans1=maxn, ans2 = maxn;
    if(ql<=m)ans1 = query1(o<<1,l,m,ql,qr);
    if(qr>=m+1)ans2 = query1(o<<1|1,m+1,r,ql,qr);
    return min(ans1, ans2);
}
int main()
{
    int n, m;
    scanf("%d %d", &n, &m);
    for(int i = 1; i <= n; i++)scanf("%d", &a[i]);
    for(int i = 1; i <= n; i++)
    {
        tt[i] = maxn;
    }
    build(1, 1, n);
    build1(1, 1, n);
    for(int i = 1; i <= m; i++)
    {
        int l, r;
        scanf("%d %d", &l, &r);
        int res = query(1, 1, n, l, r)- query1(1, 1, n, l, r);
        printf("%d\n", res);
    }
}

题目：Can you answer these queries?

题意：本题的题意是把区间的每一个数开根号，然后进行区间查询。
思路：本题的思路就是线段树的区间修改区间查询，但是这个修改，需要一些技巧，就是当这个数的区间的所有数都是1的情况下就不需要更新了，这么就不会超时了。
代码：

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

const int maxn = 1e5+10;
#define LL long long
LL st[maxn<<2], a[maxn<<2];
void build(int o, int l, int r)
{
    if(l == r)st[o] = a[l];
    else
    {
        int m = l + ((r-l)>>1);
        build(o<<1, l, m);
        build(o<<1|1, m+1, r);
        st[o] = st[o<<1] + st[o<<1|1];
    }
}
void update(int o,int l,int r,int ql, int qr)
{
    if(l==r) //若当前更新点的左右端点相等即到叶子结点时，直接更新信息并返回
    {
        st[o] = sqrt(st[o]);
        return;
    }
    if(ql<=l&&qr>=r&&st[o]==r-l+1)//如果区间内的所有数都是1则不必更新
        return;
    int m = l+((r-l)>>1);
    if(ql<=m)
        update(o<<1,l,m, ql, qr);
    if(m+1<=qr)
        update((o<<1)|1,m+1,r, ql, qr);
    st[o] = st[o<<1] + st[(o<<1)|1];//递归回之后用儿子结点更新父节点（此处是区间最大值）
}
LL query(int o,int l,int r,int ql,int qr){
    if(ql<=l&&qr>=r) return st[o];
    int m=l+((r-l)>>1);
    LL ans=0;//所需查询的结果
    if(ql<=m)ans+=query(o<<1,l,m,ql,qr);
    if(qr>=m+1)ans+=query(o<<1|1,m+1,r,ql,qr);
    return ans;
}
int main()
{
    int n, m;
    int ca = 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",++ca);
    while(m--)
    {
        int op, l, r;
        scanf("%d %d %d", &op, &l, &r);
        if(l > r)swap(l, r);//z注意题目中没有限制l, r的大小
        if(op == 0)
        {
            update(1, 1, n, l, r);
        }
        else printf("%lld\n", query(1, 1, n, l, r));
    }
    printf("\n");
    }
    return 0;
}

题目：Tunnel Warfare

题意：本题的题意很清楚，就是给一一条线段，这个线段中连接了n个村庄，然后有m个操作，D是把某个村转摧毁，R是把最近摧毁的村庄修复，注意如果最新的村庄已经修复完毕，那么下一次修复就是上一个被摧毁的，Q是查询有多少个村庄与该村庄相连接。
思路：本题的思路就是用线段树用来维护区间，如果这个村庄被摧毁那么这个位置就是0，否则就是1，然后在通过过二分查找来确定范围，注意多组输入，和不能用cin和cout.
代码：

#include<iostream>
#include<cmath>
#include<stack>
#include<cstring>
#include<cstdio>
using namespace std;

const int maxn  = 5e4+10;
stack<int>s;
int st[maxn<<2];
void build(int o, int l, int r)
{
    if(l == r)st[o] = 1;
    else
    {
        int m = l + ((r-l)>>1);
        build(o<<1, l, m);
        build(o<<1|1, m+1, r);
        st[o] = st[o<<1] + st[o<<1|1];
    }
}
void update(int o, int l, int r, int ind, int ans)
{
    if(l == r)
    {
        st[o] = ans;
        return;
    }
    int m = l+((r-l)>>1);
    if(ind <= m)update(o<<1, l, m, ind, ans);
    else update(o<<1|1, m+1, r, ind, ans);
    st[o] = st[o<<1]+st[o<<1|1];

}
int query(int o,int l,int r,int ql,int qr)
{
    if(ql<=l&&qr>=r) return st[o];
    int m=l+((r-l)>>1);
    int ans=0;
    if(ql<=m)ans+=query(o<<1,l,m,ql,qr);
    if(qr>=m+1)ans+=query(o<<1|1,m+1,r,ql,qr);
    return ans;
}

bool check(int mid, int pos, int n)
{
    if(query(1, 1, n, pos, mid) == mid-pos+1)return true;
    else return false;
}

int bsearch_2(int l, int r, int pos, int n)
{
    while (l < r)
    {
        int mid = l + r + 1 >> 1;
        if (check(mid, pos, n)) l = mid;
        else r = mid - 1;
    }
    return l;
}
bool check1(int mid, int pos, int n)
{
    if(query(1, 1, n, mid, pos) == pos-mid+1)return true;
    else return false;
}
int bsearch_1(int l, int r, int pos, int n)
{
    while (l < r)
    {
        int mid = l + r >> 1;
        if (check1(mid, pos, n)) r = mid;
        else l = mid + 1;
    }
    return l;
}
int main()
{
    int n, m;
    while(scanf("%d %d", &n,  &m)!=EOF)
    {
        build(1, 1, n);
        char op;
        while(m--)
        {
            int pos, pre;
            getchar();
            scanf("%c", &op);

            if(op == 'D')
            {
                cin>>pos;
                update(1, 1, n, pos, 0);
                s.push(pos);
            }
            else if(op == 'R')
            {
                if(s.empty())continue;
                update(1, 1, n, s.top(), 1);
                s.pop();
            }
            else
            {
                scanf("%d", &pos);
                int t = query(1, 1, n, pos, pos);
                if(t == 0)printf("0\n");
                else
                {
                    int v_r = bsearch_2(pos, n, pos, n);
                    int v_l = bsearch_1(1, pos, pos,n);
                    printf("%d\n", v_r-v_l+1);
                }
            }
        }
    }
}

题目：Assign the task

题意：题意就是给你一棵树，每次修改一个子书的所有结点，然后查询某个结点的值。
思路：本题看见修改和查询很容易想到线段树，但是这个树的子树数如果每次都搜索一遍，那么一定是非常耗时的，所以我当时就想到树链剖分，不知道是爆栈了还是我没有用明白，结果一直RE，所以我就换了一个思路采用dfs序的方法，把这棵树的所有结点重新设置一个序列，然后利用这个序列进行区间修改单点查询。
代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mid l+((r-l)>>1)
#define lson rt<<1, l, mid
#define rson rt<<1|1, mid+1, r
#define len (r-l+1)
#define Temp template<typename T>
#define len (r-l+1)
#define LL long long
Temp inline void read(T &x)
{
    x = 0;
    T w = 1, ch = getchar();
    while(!isdigit(ch) && ch!= '-')ch = getchar();
    if(ch == '-')w = -1, ch = getchar();
    while(isdigit(ch))x = (x<<3)+(x<<1)+(ch^'0'),ch = getchar();
    x = x * w;
}

const int maxn = 300000+10;
int n, q, r;
int e, beg[maxn<<1], nex[maxn<<1], to[maxn<<1], wt[maxn<<1], degree[maxn<<1];

LL a[maxn<<2];
int laz[maxn<<2];

int s[maxn], ex[maxn], cnt = 0 ;
LL res = 0;
inline void add(int x, int y)
{
    to[++e] = y;
    nex[e] = beg[x];
    beg[x] = e;
}
inline void pushdown(int rt, int l, int r)
{
    laz[rt<<1] = laz[rt];
    laz[rt<<1|1] = laz[rt];
    int m = l + ((r-l)>>1);
    a[rt<<1] = laz[rt]*(m-l+1);
    a[rt<<1|1] = laz[rt]*(r-m);
    laz[rt] = -1;

}
inline void build(int rt, int l, int r)
{
    if(l == r)
    {
        a[rt] = -1;
        return;
    }
    build(lson);
    build(rson);
    //a[rt] = (a[rt<<1]+a[rt<<1|1]);
}
inline void query(int rt, int l, int r, int L, int R)
{
    if(L <= l && r <= R)
    {
        res = a[rt];
        return;
    }
    else
    {
        if(laz[rt] != -1)pushdown(rt, l, r);
        if(L <= mid)query(lson, L, R);
        if(R > mid)query(rson, L, R);
    }
}
inline void update(int rt, int l, int r, int L, int R, int k)
{
    if(L <= l && r<= R)
    {
        laz[rt] = k;
        a[rt] = k * len;
        return;
    }
    else
    {
        if(laz[rt] != -1)pushdown(rt, l, r);
        if(L <= mid)update(lson, L, R, k);
        if(R > mid)update(rson, L, R, k);
        //a[rt] = (a[rt<<1]+a[rt<<1|1]);
    }
}

inline LL qson(int x)
{
    res  = 0;
    query(1, 1, n, s[x], s[x]);
    return res;
}
inline void updson(int x, int k)
{
    update(1, 1, n,s[x], ex[x], k);
}
void dfs(int u){
     cnt++;
     s[u] = cnt;
     for(int i = beg[u]; i; i = nex[i]){
        dfs(to[i]);
     }
     ex[u] = cnt;

}
int main()
{
    int T;
    int ca = 0;
    read(T);
    while(T--)
    {
        memset(degree, 0, sizeof degree);
        memset(laz, -1, sizeof(laz));
        memset(beg, 0, sizeof beg);

        e = 0;
        cnt  = 0;
        read(n);
        for(int i = 1; i < n; i++)
        {
            int a, b;
            read(a);
            read(b);
            add(b, a);
            degree[a]++;
        }

        for(int i = 1; i <= n; i++){
            if(degree[i] == 0){
                    r = i;
                    break;
            }
        }
        dfs(r);
        build(1, 1, n);
        read(q);
        printf("Case #%d:\n", ++ca);
        while(q--){
            char op;
            int root, val;
            cin>>op;
            if(op == 'C'){
                read(root);
                res = 0;
                printf("%lld\n",qson(root));
            }
            else {
                read(root);
                read(val);
                updson(root, val);
            }
        }
    }

    return 0;
}