acwing——线段树

主要操作：
1.pushup：由子节点算父节点 ; pushdown
2.build：将一段区间初始化成一棵线段树
3.modify：修改某一个点或一个区间（需要用到懒标记）
4.query：查询某一段区间的信息

线段树是一棵满二叉树，用一维数组存。
如果一个点的编号是x：父节点x>>1，左子节点x<<1，右子节点x<<1|1
因为倒数第二层约有n个点，因此除最后一行外有2n-1个点，所以整棵树最多4n个点。

1.最大数

//1.改某一个值 2.查某一区间最大值
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 200010;

int m , p;
struct Node{
    int l , r;
    int v;
}tr[N * 4];

void pushup(int u)//用子节点去更新父节点
{
    tr[u].v = max(tr[u << 1].v , tr[u << 1 | 1].v);
}

void build(int u , int l , int r)//建立一棵线段树
{
    tr[u] = {l , r};
    if(l == r)  return;
    int mid = l + r >> 1;
    build(u << 1 , l , mid) , build(u << 1 | 1 , mid + 1 , r);//递归向下
}

int query(int u , int l , int r)//询问某一区间内的最大值
{
    if(tr[u].l >= l && tr[u].r <= r)    return tr[u].v;
    
    int mid = tr[u].l + tr[u].r >> 1;
    int v = 0;
    if(l <= mid)    v = query(u << 1 , l , r);
    if(r > mid) v = max(v , query(u << 1 | 1 , l , r));
    
    return v;
}

void modify(int u , int x , int v)//修改第x个数
{
    if(tr[u].l == x && tr[u].r == x)    tr[u].v = v;
    else
    {
        int mid = tr[u].l + tr[u].r >> 1;
        if(x <= mid)    modify(u << 1 , x , v);
        else    modify(u << 1 | 1 , x , v);
        pushup(u);
    }
}

int main()
{
    int n = 0 , last = 0;
    cin >> m >> p;
    build(1 , 1 , m);
    
    int x;
    char op[2];
    while(m--)
    {
        cin >> op >> x;
        if(*op == 'Q')
        {
            last = query(1 , n - x + 1 , n);
            cout << last << endl;
        }
        else
        {
            modify(1 , n + 1 , (last + x) % p);
            n++;
        }
    }
    return 0;
}

拓展

2.

要求：1.修改某一个值 2.求一个区间内的最大连续子串和

分析：
1.因为有要求2当然需要在Node中加入一个元素tmax这个区间的最大连续字串和.

2.但是发现如果一个区间横跨它的左右子区间，那么仍无法计算tmax，需要用到左子区间从右开始的最大连续子段和 和 右子区间从左开始的最大连续字段和，因此引入lmax、rmax.

3.要想求lmax和rmax，也分为两种情况：未跨过分界点和跨过分界点，当计算跨过分界点时，需要用到左区间的左右区间的总和，因此还要存一个sum表示区间和。

这时结构体Node中需要加入：
①.sum区间和
②.lmax区间从左起的最大连续子串和
③.rmax区间从右起的最大连续字串和
④.tmax区间的最大连续字串和

1.求tmax分为三种情况：
i)完全在左子区间： l.tmax
ii)完全在右子区间： r.tmax
iii)横跨左右子区间：l.rmax + r.lmax
因此u.tmax = max(max(l.tmax , r.tmax) , l.rmax + r.lmax)

2.求lmax分为两种情况：
i).未跨过分界点:l.lmax
ii).跨过分界点：l.sum + r.lmax
因此：u.lmax = max(l.lmax , l.sum + r.lmax)

3.求rmax和求lmax相同相同

//1.修改某一个值 2.求一个区间内的最大连续字串和
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 500010;

struct Node{
    int l , r;
    int sum , lmax , rmax , tmax;
}tr[N * 4];

int n , m;
int w[N];

void pushup(Node &u , Node &l , Node &r)
{
    u.sum = l.sum + r.sum;
    u.lmax = max(l.lmax , l.sum + r.lmax);
    u.rmax = max(r.rmax , l.rmax + r.sum);
    u.tmax = max(max(l.tmax , r.tmax) , l.rmax + r.lmax);
}

void pushup(int u)
{
    pushup(tr[u] , tr[u << 1] , tr[u << 1 | 1]);
}

void build(int u , int l , int r)
{
    if(l == r)  tr[u] = {l , r , w[l] , w[l] , w[l] , w[l]};
    else
    {
        tr[u] = {l , r};
        int mid = l + r >> 1;
        build(u << 1 , l , mid);
        build(u << 1 | 1 , mid + 1 , r);
        pushup(u);
    }
}

void modify(int u , int x , int v)
{
    if(tr[u].l == x && tr[u].r == x)    tr[u] = {x , x , v , v , v , v};
    else
    {
        int mid = tr[u].l + tr[u].r >> 1;
        if(x <= mid)    modify(u << 1, x , v);
        else    modify(u << 1 | 1 , x , v);
        pushup(u);
    }
    
}

Node query(int u , int l , int r)
{
    if(tr[u].l >= l && tr[u].r <= r)    return tr[u];
    
    int mid = tr[u].l + tr[u].r >> 1;
    if(r <= mid)    return query(u << 1 , l , r);
    else if(mid < l)    return query(u << 1 | 1 , l , r);
    else
    {
        auto left = query(u << 1 , l , r);
        auto right = query(u << 1 | 1 ,l , r);
        Node res;
        pushup(res , left , right);
        return res;
    }
}

int main()
{
    cin >> n >> m;
    for(int i = 1 ; i <= n ; i++)   cin >> w[i];
    
    build(1 , 1 , n);
    
    int k , x , y;
    while(m--)
    {
        cin >> k >> x >> y;
        if(k == 1)
        {
            if(x > y)   swap(x , y);
            cout << query(1 , x , y).tmax << endl;
        }
        else
            modify(1 , x , y);
    }
    
    return 0;
}

3.
要求：1.区间增加一个数 2.求区间内最大公约数

分析：
1.要想求一个区间内的gcd，只要求左右子区间的gcd的gcd即可，因此在Node中多存一个gcd即可。

证明：gcd( a₁ , a₂ , a₃ ,… a_n , ) = gcd( a₁ , a₂-a₁ a₃-a₂ ,… a_n -a_n-1, )

step1：证明：左边≤右边 令左边=d，即证d是右边的某一个公约数，即d是右边括号内每一个数的约数. 因为d能整除a₁ , a₂ , a₃ ,… a_n，因此d能整除这些数两两之间的差值，因此可以整除右边括号内的每一个值。
step2：证明：左边≥右边 同理令右边等d，因为d整除a₁ , a₂-a₁，所以能整除这俩的和a₂，依次类推可以整除a₃、a₄…
得证：左边等于右边

因此需要维护一个差分数组b（b_i=a_i-a_i-1）

2.而给区间增加一个数同样也需要差分数组，因此只需要维护一个差分数组即可！

4.

要求：1.区间修改（pushdown） 2.区间查询

分析：因为在查询时遇到一个完整的区间直接返回值，受此启发，我们在区间修改时如果遇到完整区间同样停止，然后在这个区间打上标记add。

这是Node中需要加入：
①sum:当前区间的总和。
②add：懒标记，以当前节点为根的子树中的每一个节点加上一个add（不包含根节点）

#include <iostream>
#include <algorithm>

using namespace std;

typedef long long LL;

const int N = 100010;

int n , m;
int w[N];
struct Node{
    int l , r;
    LL sum , add;
}tr[N * 4];

void pushup(int u)
{
    tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
}

void pushdown(int u)
{
    auto &root = tr[u] , &left = tr[u << 1] , &right = tr[u << 1 | 1];
    if(root.add)
    {
        left.add += root.add , left.sum += (LL)(left.r - left.l + 1) * root.add;
        right.add += root.add , right.sum += (LL)(right.r - right.l + 1) * root.add;
        root.add = 0;
    }
}

void build(int u , int l , int r)
{
    if(l == r) tr[u] = {l , l , w[l] , 0};
    else
    {
        tr[u] = {l , r};
        int mid = tr[u].l + tr[u].r >> 1;
        build(u << 1 , l , mid) , build(u << 1 | 1 , mid + 1 , r);
        pushup(u);
    }
}

void modify(int u , int l , int r , int d)
{
    if(tr[u].l >= l && tr[u].r <= r)
    {
        tr[u].sum += (LL)(tr[u].r - tr[u].l + 1) * d;
        tr[u].add += d;
    }
    else
    {
        pushdown(u);
        int mid = tr[u].l + tr[u].r >> 1;
        if(l <= mid)    modify(u << 1 , l , r , d);
        if(r > mid)    modify(u << 1 | 1 , l , r , d);
        pushup(u);
    }
}

LL query(int u , int l , int r)
{
    if(tr[u].l >= l && tr[u].r <= r)    return tr[u].sum;
    
    pushdown(u);
    int mid = tr[u].l + tr[u].r >> 1;
    LL sum = 0;
    if(l <= mid)    sum = query(u << 1 , l , r);
    if(r > mid)     sum += query(u << 1 | 1 , l , r);
    return sum;
}

int main()
{
    cin >> n >> m;
    
    for(int i = 1 ; i <= n ; i++)   cin >> w[i];
    
    build(1 , 1 , n);
    
    char op[2];
    int l , r , d;
    
    while(m--)
    {
        cin >> op >> l >> r;
        if(*op == 'C')
        {
            cin >> d;
            modify(1 , l , r , d);
        }
        else
            cout << query(1 , l , r) << endl;
    }
    
    return 0;
}