线段树及主席树

线段树及主席树

个人理解

线段树理解

由于只是一个个人笔记，故这里不再赘述
参考博客
https://www.cnblogs.com/jason2003/p/9676729.html

线段树模板

#include<iostream>
#include<string.h>
#define max 1000
#define INFINITY 9999999
using namespace std;

struct node
{
    
    
    int data;
    int l,r;
    int sum;
    int min;
    int lazy;//延迟标记
    int addmark;//
}SegTree[max];

int arr[max]={
    
    0};

int min(int a,int b){
    
    
    return a<b?a:b;
}

void pushdown(int root)
{
    
    
    if(SegTree[root].addmark!=0){
    
    
        //设置左右孩子的标志域,孩子节点可能被多次延迟
        SegTree[root*2].addmark+=SegTree[root].addmark;
        SegTree[root*2+1].addmark+=SegTree[root].addmark;
        //更新
        SegTree[root*2].data+=SegTree[root].addmark;
        SegTree[root*2+1].data+=SegTree[root].addmark;
        SegTree[root].addmark=0;//清空
    }
}

void bulid(int root,int arr[],int l,int r)//区间最小值
{
    
    
    SegTree[root].l=l,SegTree[root].r=r;
    if(l==r){
    
    
        SegTree[root].data=arr[l];
        SegTree[root].sum=arr[l];
    }
    else{
    
       
        int mid=(l+r)/2;
        bulid(root*2,arr,l,mid);//递归构造左子树
        bulid(root*2+1,arr,mid+1,r);
        SegTree[root].data=min(SegTree[root*2].data,SegTree[root*2+1].data);
        SegTree[root].sum=SegTree[root*2].sum+SegTree[root*2+1].sum;
    }
}

//区间查询
int query(int k,int l,int r)//l~r<=k.l~k.r
{
    
    
    if(SegTree[k].lazy)//下传懒惰标记
        pushdown(k);
    if(SegTree[k].l==l&&SegTree[k].r==r)//区间正好
        return SegTree[k].sum;
    int mid=(SegTree[k].l+SegTree[k].r)/2;
    if(r<=mid)
        return query(k*2,l,r);
    if(l>mid)
        return query(k*2+1,l,r);
    return query(k*2,l,mid)+query(k*2+1,mid+1,r);
}

//区间更新
void update(int i,int l,int r,int k)
{
    
    
    if(SegTree[i].r<=r && SegTree[i].l>=l)//如果当前区间被完全覆盖在目标区间里，讲这个区间的sum+k*(tree[i].r-tree[i].l+1)
    {
    
    
        SegTree[i].sum+=k*(SegTree[i].r-SegTree[i].l+1);
        SegTree[i].lazy+=k;//记录lazytage
        return ;
    }
    pushdown(i);//向下传递
    if(SegTree[i*2].r>=l)
        update(i*2,l,r,k);
    if(SegTree[i*2+1].l<=r)
        update(i*2+1,l,r,k);
    SegTree[i].sum=SegTree[i*2].sum+SegTree[i*2+1].sum;
    return ;
}

//单点更新
void add(int i,int dis,int k)
{
    
    
    if(SegTree[i].l==SegTree[i].r){
    
    
        SegTree[i].sum+=k;
        return;
    }
    if(dis<=SegTree[i*2].r) add(i*2,dis,k);
    else add(i*2+1,dis,k);
    SegTree[i].sum=SegTree[i*2].sum+SegTree[i*2+1].sum;
    return;
}

int main()
{
    
    
    memset(SegTree,0,sizeof(SegTree));
    arr[1]=4,arr[2]=3,arr[3]=2,arr[4]=1,arr[5]=5,arr[6]=6;
    bulid(1,arr,1,6);
    cout << query(1,1,6) << endl;
    add(1,1,2);
    cout << query(1,1,6) << endl;
    update(1,1,6,1);
    cout << query(1,1,6) << endl;
    return 0;
}

主席树理解（可持久化线段树）

关于主席树的话，有一道模板题，也就是问题D，这个问题很容易理解，就是给定一串序列，再给出一个区间，求该区间的第k大的数，而主席树就适用于这种情况
例如，给定序列4，1，3，2，查找区间[2,4]的第2大的数

由于只是一个个人笔记，故这里不再赘述
参考博客
https://www.cnblogs.com/zyf0163/p/4749042.html
https://blog.csdn.net/pengwill97/article/details/80920143

问题 A: 敌兵布阵

题目描述

C国的死对头A国这段时间正在进行军事演习，所以C国间谍头子Derek和他手下Tidy又开始忙乎了。A国在海岸线沿直线布置了N个工兵营地，Derek和Tidy的任务就是要监视这些工兵营地的活动情况。由于采取了某种先进的监测手段，所以每个工兵营地的人数C国都掌握的一清二楚，每个工兵营地的人数都有可能发生变动，可能增加或减少若干人手，但这些都逃不过C国的监视。

输入

第一行一个整数T，表示有T组数据。

每组数据第一行有一个正整数N（N<=50000），表示敌人有N个工兵营地，接下来一行有N个正整数，第i个正整数ai代表第i个工兵营地里开始时有ai个人（1<=ai<=50）。

接下来每行有一条命令，命令有4种形式：

(1) Add i j，i和j为正整数，表示第i个营地增加j个人（j不超过30）；

(2) Sub i j，i和j为正整数，表示第i个营地减少j个人（j不超过30）；

(3) Query i j，i和j为正整数，i<=j，表示询问第i到第j个营地的总人数；

(4) End 表示结束，这条命令在每组数据最后出现。

输出

对第i组数据，首先输出“Case i:”和回车，

对于每个Query询问，输出一个整数并回车，表示询问的段中的总人数，这个数保持在int以内。

样例输入

1
10
1 2 3 4 5 6 7 8 9 10
Query 1 3
Add 3 6
Query 2 7
Sub 10 2
Add 6 3
Query 3 10
End

样例输出

Case 1:
6
33
59

代码

#include<iostream>
#include<string.h>
#include<string>
#define max 1000
#define INFINITY 9999999
using namespace std;

struct node
{
    
    
    int data;
    int l,r;
    int sum;
    int min;
    int lazy;//延迟标记
    int addmark;//
}SegTree[max];

int arr[max]={
    
    0};//得从1开始

int min(int a,int b){
    
    
    return a<b?a:b;
}

void pushdown(int root)
{
    
    
    if(SegTree[root].addmark!=0){
    
    
        //设置左右孩子的标志域,孩子节点可能被多次延迟
        SegTree[root*2].addmark+=SegTree[root].addmark;
        SegTree[root*2+1].addmark+=SegTree[root].addmark;
        //更新
        SegTree[root*2].data+=SegTree[root].addmark;
        SegTree[root*2+1].data+=SegTree[root].addmark;
        SegTree[root].addmark=0;//清空
    }
}

void bulid(int root,int arr[],int l,int r)//区间最小值
{
    
    
    SegTree[root].l=l,SegTree[root].r=r;
    if(l==r){
    
    
        SegTree[root].data=arr[l];
        SegTree[root].sum=arr[l];
    }
    else{
    
       
        int mid=(l+r)/2;
        bulid(root*2,arr,l,mid);//递归构造左子树
        bulid(root*2+1,arr,mid+1,r);
        SegTree[root].data=min(SegTree[root*2].data,SegTree[root*2+1].data);
        SegTree[root].sum=SegTree[root*2].sum+SegTree[root*2+1].sum;
    }
}

//区间查询
int query(int k,int l,int r)//l~r<=k.l~k.r
{
    
    
    if(SegTree[k].lazy)//下传懒惰标记
        pushdown(k);
    if(SegTree[k].l==l&&SegTree[k].r==r)//区间正好
        return SegTree[k].sum;
    int mid=(SegTree[k].l+SegTree[k].r)/2;
    if(r<=mid)
        return query(k*2,l,r);
    if(l>mid)
        return query(k*2+1,l,r);
    return query(k*2,l,mid)+query(k*2+1,mid+1,r);
}

//区间更新
void update(int i,int l,int r,int k)
{
    
    
    if(SegTree[i].r<=r && SegTree[i].l>=l)//如果当前区间被完全覆盖在目标区间里，讲这个区间的sum+k*(tree[i].r-tree[i].l+1)
    {
    
    
        SegTree[i].sum+=k*(SegTree[i].r-SegTree[i].l+1);
        SegTree[i].lazy+=k;//记录lazytage
        return ;
    }
    pushdown(i);//向下传递
    if(SegTree[i*2].r>=l)
        update(i*2,l,r,k);
    if(SegTree[i*2+1].l<=r)
        update(i*2+1,l,r,k);
    SegTree[i].sum=SegTree[i*2].sum+SegTree[i*2+1].sum;
    return ;
}

//单点更新
void add(int i,int dis,int k)
{
    
    
    if(SegTree[i].l==SegTree[i].r){
    
    
        SegTree[i].sum+=k;
        return;
    }
    if(dis<=SegTree[i*2].r) add(i*2,dis,k);
    else add(i*2+1,dis,k);
    SegTree[i].sum=SegTree[i*2].sum+SegTree[i*2+1].sum;
    return;
}

int main()
{
    
    
    int t;
    cin >> t;
    for(int i=1;i<=t;i++){
    
    
        cout << "Case 1:" << endl;
        memset(SegTree,0,sizeof(SegTree));
        int temp;
        cin >> temp;
        for(int j=1;j<=temp;j++)cin >> arr[j];
        bulid(1,arr,1,temp);
        string str;
        int a,b;
        while(1){
    
    
            cin >> str;
            if(str.compare("End")==0){
    
    
                break;
            }
            cin >> a >> b;
            if(str.compare("Query")==0){
    
    
                cout << query(1,a,b) << endl;
            }
            if(str.compare("Add")==0){
    
    
                add(1,a,b);
            }
            if(str.compare("Sub")==0){
    
    
                add(1,a,-b);
            }
        }
    }
    return 0;
}

问题 B: 最大数

题目描述

输入

输出

样例输入

5 100
A 96
Q 1
A 97
Q 1
Q 2

样例输出

96
93
96

代码1（WC）

#include<iostream>
#include<string.h>
#include<string>
#define max 400000
#define INFINITY 0x3f3f3f3f
using namespace std;

struct node
{
    
    
    int data;
    int l,r;
    int sum;
    int lazy;//延迟标记
    int addmark;//
}SegTree[max];

int arr[max];//得从1开始
const int NR=100000;//线段树区间右端点(尽量大)
int index1=0;//更新指针
int t=0;

int maxfun(int a,int b){
    
    
    return a>=b?a:b;
}
void bulid(int root,int arr[],int l,int r)//区间最大值
{
    
    
    SegTree[root].l=l,SegTree[root].r=r;
    if(l==r){
    
    
        SegTree[root].data=arr[l];
        SegTree[root].sum=arr[l];
    }
    else{
    
       
        int mid=(l+r)/2;
        bulid(root*2,arr,l,mid);//递归构造左子树
        bulid(root*2+1,arr,mid+1,r);
        //区间最大值建树
        SegTree[root].data=maxfun(SegTree[root*2].data,SegTree[root*2+1].data);
    }
}

//区间查询最大值
int query(int k,int l,int r,int x,int y)//l~r<=k.l~k.r
{
    
    
    // 
    if(x<=l&&r<=y)
        return SegTree[k].data;
    //int mid=(SegTree[k].l+SegTree[k].r)/2;
    int mid=(l+r)>>1;
    return maxfun(query(k*2,l,mid,x,y),query(k*2+1,mid+1,r,x,y));
    // if(r<=mid)//如果区间在大区间左边
    //     return query(k*2,l,r);
    // if(l>mid)//如果区间在大区间右边
    //     return query(k*2+1,l,r);
}

//单点更新
void add(int i,int l,int r,int dis,int k)
{
    
    
    if(dis>r||dis<l)return;
    if(SegTree[i].l==SegTree[i].r&&dis==l){
    
    
        SegTree[i].data=k;
        return;
    }
    int mid=(l+r)>>1;
    if(dis<=mid) add(i*2,l,mid,dis,k);
    else add(k*2+1,mid+1,r,dis,k);
    // if(dis<=SegTree[i*2].r) add(i*2,dis,k);
    // else add(i*2+1,dis,k);
    SegTree[i].data=maxfun(SegTree[i*2].data,SegTree[i*2+1].data);
}

int main()
{
    
    
    memset(SegTree,0,sizeof(SegTree));
    memset(arr,0,sizeof(arr));
    bulid(1,arr,1,NR);//1~1000区间的数组,起始为0
    int M,D;
    cin >> M >> D;
    for(int i=1;i<=M;i++){
    
    
        char option;
        int a;
        cin >> option >> a;
        if(option=='A'){
    
    
            add(1,1,M,++index1,(a+t)%D);
        }else{
    
    
            t=query(1,1,M,index1-a+1,index1);
            cout << t << endl;
        }
    }
    return 0;
}

代码2（AC）

#include <iostream>
using namespace std;
#define INF 0x3f3f3f3f
#define M 2000005

int nown,m;
long long t,d;
long long s[4*M];

long long maxfun(long long a,long long b){
    
    
    return a>=b?a:b;
}

//单点更新
void update(int k,int l,int r,int x,int v)
{
    
    	
	if(x>r||x<l)return;
	if(l==r&&x==l)
	{
    
    
		s[k]=v;
		return;
	}
	int mid=(l+r)>>1;
	if(x<=mid) update(k*2,l,mid,x,v);
	else update(k*2+1,mid+1,r,x,v);
	s[k]=maxfun(s[k*2],s[k*2+1]);
}

//查询最大值
long long query(int k,int l,int r,int x,int y)
{
    
    
	if(x>r||y<l)return -INF;
	if(x<=l&&r<=y)return s[k];
	int mid=(l+r)>>1;
	return maxfun(query(k*2,l,mid,x,y),query(k*2+1,mid+1,r,x,y));
}

int main()
{
    
    
	cin >> m >> d;
	for(int i=1; i<=m; i++)
	{
    
    
		char flag;
		int x;
		cin >> flag >> x;
		if(flag=='Q'){
    
    
			t=query(1,1,m,nown-x+1,nown);
			cout << t << endl;
		}else update(1,1,m,++nown,(x+t)%d);
	}
	return 0;
}

问题 C: Distinct Characters Queries(英文题面)(线段树)

题目描述

输入

输出

样例输入

abacaba
5
2 1 4
1 4 b
1 5 b
2 4 6
2 1 7

样例输出

3
1
2

代码

#include<iostream>
#include<string.h>
#define max 1000
#define INFINITY 9999999
using namespace std;

struct node
{
    
    
    int data;
    int l,r;
    int sum;
    int lazy;//延迟标记
    int addmark;//
}SegTree[max];

char arr[100];

void pushdown(int root)
{
    
    
    if(SegTree[root].addmark!=0){
    
    
        //设置左右孩子的标志域,孩子节点可能被多次延迟
        SegTree[root*2].addmark+=SegTree[root].addmark;
        SegTree[root*2+1].addmark+=SegTree[root].addmark;
        //更新
        SegTree[root*2].data+=SegTree[root].addmark;
        SegTree[root*2+1].data+=SegTree[root].addmark;
        SegTree[root].addmark=0;//清空
    }
}

void bulid(int root,char arr[],int l,int r)//区间最小值
{
    
    
    SegTree[root].l=l,SegTree[root].r=r;
    if(l==r){
    
    
        int x=arr[l-1]-'a';
        int temp=1;
        SegTree[root].sum=(temp<<x);
    }
    else{
    
       
        int mid=(l+r)/2;
        bulid(root*2,arr,l,mid);//递归构造左子树
        bulid(root*2+1,arr,mid+1,r);
        SegTree[root].sum=(SegTree[root*2].sum|SegTree[root*2+1].sum);
    }
}

//区间查询
int query(int k,int l,int r)//l~r<=k.l~k.r
{
    
    
    if(SegTree[k].lazy)//下传懒惰标记
        pushdown(k);
    if(SegTree[k].l==l&&SegTree[k].r==r)//区间正好
        return SegTree[k].sum;
    int mid=(SegTree[k].l+SegTree[k].r)/2;
    if(r<=mid)
        return query(k*2,l,r);
    if(l>mid)
        return query(k*2+1,l,r);
    return (query(k*2,l,mid)|query(k*2+1,mid+1,r));
}

//单点更新
void add(int i,int dis,char k)
{
    
    
    if(SegTree[i].l==SegTree[i].r){
    
    
        int x=k-'a';
        int temp=1;
        SegTree[i].sum=(temp<<x);
        return;
    }
    if(dis<=SegTree[i*2].r) add(i*2,dis,k);
    else add(i*2+1,dis,k);
    SegTree[i].sum=(SegTree[i*2].sum|SegTree[i*2+1].sum);
    return;
}

int cnt(int x)
{
    
    
    int c=0;
    while(x>0){
    
    
        if((x&1)==1)c++;
        x>>=1;
    }
    return c;
}

int main()
{
    
    
    memset(SegTree,0,sizeof(SegTree));
    memset(arr,0,sizeof(arr));
    cin >> arr;
    bulid(1,arr,1,strlen(arr));
    int t;
    cin >> t;
    while(t--){
    
    
        int temp;
        cin >> temp;
        if(temp==1){
    
    //单点修改
            int index;
            char a;
            cin >> index >> a;
            add(1,index,a);
        }else{
    
    //区间查询
            int a,b;
            cin >> a >> b;
            cout << cnt(query(1,a,b)) << endl;
        }
    }
    return 0;
}

问题 D: Kth number

题目描述

Give you a sequence and ask you the kth big number of a inteval.

输入

The first line is the number of the test cases.

For each test case, the first line contain two integer n and m (n, m <= 100000), indicates the number of integers in the sequence and the number of the quaere.
The second line contains n integers, describe the sequence.
Each of following m lines contains three integers s, t, k.

输出

For each test case, output m lines. Each line contains the kth big number.

样例输入

1
10 1
1 4 2 3 5 6 7 8 9 0
1 3 2

样例输出

2

代码

#include<iostream>
#include<algorithm>
using namespace std;
// const int maxn = 1e5 + 10;
const int maxn = 1000;
int n, m;
int cnt;
struct node
{
    
    
    int L, R;//分别指向左右子树
    int sum;//该节点所管辖区间范围内数的个数
    node(){
    
    sum = 0;}
}Tree[maxn * 20];

struct value
{
    
    
    int x;//值的大小
    int id;//离散之前在原数组中的位置
}Value[maxn];

bool cmp(value v1, value v2)//从小到大
{
    
    
    return v1.x < v2.x;
}

int root[maxn];//多颗线段树的根节点
int rank1[maxn];//原数组离散之后的数组

void init()
{
    
    
    cnt = 1;//计数器
    root[0] = 0;
    Tree[0].L = Tree[0].R = Tree[0].sum = 0;
}

void update(int num, int &rt, int l, int r)//num即为4，1，3，2
{
    
    
    Tree[cnt] = Tree[rt];//新建节点，继承上一个节点?
    cnt++;
    rt = cnt - 1;//连接节点,rt指向新节点
    Tree[rt].sum++;//新节点加1
    if(l == r) return;//到达叶子节点
    int mid = (l + r)>>1;
    //往左往右更新
    if(num <= mid) update(num, Tree[rt].L, l, mid);//rt为新节点的左
    else update(num, Tree[rt].R, mid + 1, r);//rt为新节点的右
}

int query(int i, int j, int k, int l, int r)
{
    
    
    //就像前缀和，左子树减左子树，得到d，即为[l,r]区间的左边的个数，如果k<d,就去左边找,如果k>d就去右边找
    int d = Tree[Tree[j].L].sum - Tree[Tree[i].L].sum;
    if(l == r) return l;
    int mid = (l + r)>>1;
    if(k <= d) return query(Tree[i].L, Tree[j].L, k, l, mid);
    else return query(Tree[i].R, Tree[j].R, k - d, mid + 1, r);
}

int main()
{
    
    
    int t;
    cin >> t;
    while(t--){
    
    
        cin >> n >> m;
        for(int i = 1; i <= n; i++){
    
    
            cin >> Value[i].x;
            Value[i].id = i;
        }
        //进行离散化
        //将value节点数组按x值从小到大排序
        sort(Value + 1, Value + n + 1, cmp);
        for(int i = 1; i <= n; i++)
            rank1[Value[i].id] = i;
        init();
        for(int i = 1; i <= n; i++){
    
    
            root[i] = root[i - 1];
            update(rank1[i], root[i], 1, n);
        }
        int left, right, k;
        for(int i = 1; i <= m; i++){
    
    
            cin >> left >> right >> k;
            cout << Value[query(root[left - 1], root[right], k, 1, n)].x << endl;
        }
    }
    return 0;
}

目的

一个笔记