2020-11-21 一周总结线段树

总结之前先来点好玩的，
1.printf("%d%c",x," \n"[i==last]) ,非常骚气的换行，(在看别人题解时发现的)" \n"[i==last] ,当i==last 返回" \n"[1]就是’\n’，否则返回 ’ ';
2.读入10以上位的整数你还是只会用字符串吗，可以用整形数组

int a[N];
for(int i=0;i<N;i++) scanf("%1d",a[i]); //控制每次只读入一个整数

线段树1

维护区间的各种属性（最大值，最小值，区间和，最大公约数）
基操：
build（）建树
pushup（）由子区间更新父区间
query（）查询区间
modify（）单点修改

分类问题：带权边做法，扩展域做法

餐前甜点

最大数

给定一个正整数数列 a1,a2,…,an，每一个数都在 0∼p−1 之间。

可以对这列数进行两种操作：

添加操作：向序列后添加一个数，序列长度变成 n+1；
询问操作：询问这个序列中最后 L 个数中最大的数是多少。
程序运行的最开始，整数序列为空。

写一个程序，读入操作的序列，并输出询问操作的答案。

输入格式
第一行有两个正整数 m,p，意义如题目描述；

接下来 m 行，每一行表示一个操作。

如果该行的内容是 Q L，则表示这个操作是询问序列中最后 L 个数的最大数是多少；

如果是 A t，则表示向序列后面加一个数，加入的数是 (t+a) mod p。其中，t 是输入的参数，a 是在这个添加操作之前最后一个询问操作的答案（如果之前没有询问操作，则 a=0）。

第一个操作一定是添加操作。对于询问操作，L>0 且不超过当前序列的长度。

输出格式
对于每一个询问操作，输出一行。该行只有一个数，即序列中最后 L 个数的最大数。

数据范围
1≤m≤2×105,
1≤p≤2×109,
0≤t<p
输入样例：
10 100
A 97
Q 1
Q 1
A 17
Q 2
A 63
Q 1
Q 1
Q 3
A 99
输出样例：
97
97
97
60
60
97
样例解释
最后的序列是 97,14,60,96。
思路：裸线段树，线段树维护区间最大值

#include<iostream>

using namespace std;
const int N = 2e5+10;
struct node{
    int l,r;
    int maxx;
}tr[4*N];
int m,p;

void build(int u,int l,int r)
{
    tr[u]={l,r};
    if(l==r) return;
    else{
        int mid = l+r >> 1;
        build(u<<1,l,mid),build(u<<1|1,mid+1,r);
        //pushup(u);  大多数情况要回溯回来；
    }
}

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

void modify(int u,int x,int v)
{
    if(tr[u].l==x&&tr[u].r==x) tr[u].maxx=max(v,tr[u].maxx);
    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 query(int u,int l,int r)
{
    if(tr[u].l>=l&&tr[u].r<=r) return tr[u].maxx;
    else{
        int mid=tr[u].l+tr[u].r >> 1,maxx=0;
        if(l<=mid) maxx=query(u<<1,l,r);
        if(r>mid) maxx=max(maxx,query(u<<1|1,l,r));
        return maxx;
    }
}
int main()
{
    scanf("%d%d",&m,&p);
    build(1,1,m);
    int cnt=1,last=0;
    while(m--)
    {
        char op[2];
        int x;
        scanf("%s%d",op,&x);
        if(*op=='Q'){
            last = query(1,cnt-x,cnt-1);
            printf("%d\n",last);
        }
        else{
            modify(1,cnt,(last+x)%p);
            cnt++;
        }
    }
    return 0;
}

放大招

区间最大公约数

给定一个长度为N的数列A，以及M条指令，每条指令可能是以下两种之一：

1、“C l r d”，表示把 A[l],A[l+1],…,A[r] 都加上 d。

2、“Q l r”，表示询问 A[l],A[l+1],…,A[r] 的最大公约数(GCD)。

对于每个询问，输出一个整数表示答案。

输入格式
第一行两个整数N,M。

第二行N个整数A[i]。

接下来M行表示M条指令，每条指令的格式如题目描述所示。

输出格式
对于每个询问，输出一个整数表示答案。

每个答案占一行。

数据范围
N≤500000,M≤100000
输入样例：
5 5
1 3 5 7 9
Q 1 5
C 1 5 1
Q 1 5
C 3 3 6
Q 2 4
输出样例：
1
2
4

思路：区间问题可以联想树状数组，线段树，求区间最大公约数，可以用线段树维护，区间修改用懒标记吗？，观察发现，区间一起加减某个数可以用差分数组维护，同时，根据辗转相除可知，gcd(a1,a2,a3…an-1,an)==gcd(a1,a2-a1,a3-a2…an-an-1);可以用线段树维护差分数组的区间最大公约数，同时，维护差分数组的前缀和。

线段树做法

#include<iostream>
#include<cmath>
using namespace std;
const int N = 5e5+10;
typedef long long ll;//输入较大，要用long long 来存
ll w[N];

struct node
{
    int l,r;
    ll sum,d;//查分数组的前缀和与区间最大约数
}tr[4*N];

ll gcd(ll a,ll b) //欧几里得算法
{
    return b?gcd(b,a%b):a;
}

void pushup(node &u,node &l,node &r)//用两个子区间更新总区间
{
    u.sum=l.sum+r.sum;
    u.d=gcd(l.d,r.d);
}
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) 
    {
        ll b=w[r]-w[l-1];
        tr[u]={l,l,b,b};
    }
    else{
        int mid = l+r >> 1;
        tr[u]={l,r};
        build(u<<1,l,mid),build(u<<1|1,mid+1,r);
        pushup(u);
    }
}

void modify(int u,int x,ll v)
{
    if(tr[u].l==x&&tr[u].r==x) tr[u].sum+=v,tr[u].d+=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(tr[u],tr[u<<1],tr[u<<1|1]);
    }
}

node query(int u,int l,int r)
{
    if(tr[u].l>=l&&tr[u].r<=r) return tr[u];
    else{
        int mid=tr[u].l+tr[u].r >>1;
        if(r<=mid) return query(u<<1,l,r);
        else if(l>mid) 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()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) scanf("%lld",&w[i]);
    build(1,1,n);
    while(m--)
    {           
        char op[2];
        int l,r;
        ll d;
        scanf("%s%d%d",op,&l,&r);
        if(op[0]=='C'){
            scanf("%lld",&d);
            modify(1,l,d);
            if(r+1<=n) modify(1,r+1,-d);
        }
        else{
            auto left = query(1,1,l);
            auto right = query(1,l+1,r);
            printf("%lld\n",abs(gcd(left.sum,right.d)));
        }
    }
    return 0;
}

线段树+树状数组做法

#include<iostream>
#include<cmath>
using namespace std;
const int N = 5e5+10;
typedef long long ll;
ll w[N],tri[N];
int n,m;

struct node
{
    int l,r;
    ll d;
}tr[4*N];

ll gcd(ll a,ll b)
{
    return b?gcd(b,a%b):a;
}

void pushup(node &u,node &l,node &r)
{
    u.d=gcd(l.d,r.d);
}
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,l,w[r]-w[l-1]};
    }
    else{
        int mid = l+r >> 1;
        tr[u]={l,r};
        build(u<<1,l,mid),build(u<<1|1,mid+1,r);
        pushup(u);
    }
}

void modify(int u,int x,ll v)
{
    if(tr[u].l==x&&tr[u].r==x) tr[u].d+=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(tr[u],tr[u<<1],tr[u<<1|1]);
    }
}

node query(int u,int l,int r)
{
    if(tr[u].l>=l&&tr[u].r<=r) return tr[u];
    else{
        int mid=tr[u].l+tr[u].r >>1;
        if(r<=mid) return query(u<<1,l,r);
        else if(l>mid) 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 lowbit(int x)
{
    return x&-x;
}

void add(int x,ll b)
{
    for(int i=x;i<=n;i+=lowbit(i))
        tri[i]+=b;
}

ll sum(int x)
{
    ll ans=0;
    for(int i=x;i;i-=lowbit(i)) ans+=tri[i];
    return ans;
}

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) scanf("%lld",&w[i]);
    build(1,1,n);
    for(int i=1;i<=n;i++) add(i,w[i]-w[i-1]);
    while(m--)
    {           
        char op[2];
        int l,r;
        ll d;
        scanf("%s%d%d",op,&l,&r);
        if(op[0]=='C'){
            scanf("%lld",&d);
            modify(1,l,d),add(l,d);
            if(r+1<=n) modify(1,r+1,-d),add(r+1,-d);
        }
        else{
            auto right = query(1,l+1,r);
            printf("%lld\n",abs(gcd(sum(l),right.d)));
        }
    }
    return 0;
}