简单数据结构模板

1，树状数组

int C[maxn<<4] , a[maxn] , n;

int lowbit(int x){
    return x&(-x);
}

int Sum(int pos){
    int ans = 0;
    while(pos>0) ans += C[pos] , pos -= lowbit(pos);
    return ans ;
}

void Update(int pos,int add_num){
    while(pos<maxn) C[pos] += add_num , pos += lowbit(pos);
}

2，RMQ树

int a[maxn] , dp[maxn][30] , n;

void RMQ()
{
    MT(dp,0);
    for(int i=0;i<n;i++) dp[i][0]=a[i];

    for(int j=1;j<30;j++) for(int i=0;(i+(1<<j))<=n;i++)
            dp[i][j]=max(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);

}

int Query(int l, int r)
{
    int len = r-l+1 , e = 0;
    while(1<<(1+e) <= len) e ++;
    return max( dp[l][e] , dp[r-(1<<e)+1][e] );
}

3，字典树

struct node{
    int cnt;
    node* child[26];
};
node* root = new node();

void Insert(string s)
{
    node* now = root;
    for(int i=0;s[i];i++)
    {
        int p = s[i] - 'a';
        if(!now->child[p]) now->child[p] = new node();
        now = now->child[p];
        now -> cnt++;
    }
}

int Query(string s)
{
    node* now = root;
    for(int i=0;s[i];i++)
    {
        int p = s[i] - 'a';
        if(!now->child[p]) return 0;
        now = now->child[p];
    }
    return now->cnt;
}

void Delete(string s)
{
    node* now = root;
    for(int i=0;s[i];i++)
    {
        int p = s[i] - 'a';
        if(now->child[p]->cnt == 1)
        {
            now->child[p] = NULL;
            return ;
        }
        now = now->child[p];
        now->cnt--;
    }
}

4，线段树单点修改（单点修改，询问区间最大值）

int tree[2*maxn],a[maxn];
int ql = 0, qr = 0;
int pos = 0 , v = 0;

void BuildTree(int l,int r,int node)
{
    if(l == r) tree[node] = a[l];
    else
    {
        int mid = (l + r) >> 1;
        BuildTree(l, mid , node<<1);
        BuildTree(mid+1 , r , (node<<1)+1);
        tree[node] = max(tree[node<<1] , tree[(node<<1)+1]);
    }
}

void UpdateTree(int l ,int r, int node)
{
    if(l == r) tree[node] = v;
    else
    {
        int mid = (l + r) >> 1;
        if(pos <= mid) UpdateTree(l , mid , node<<1);
        else           UpdateTree(mid+1 , r , (node<<1)+1);
        tree[node] = max(tree[node<<1] , tree[(node<<1)+1]);
    }
}

int Query(int l , int r ,int node)
{
    if(l >= ql && r <= qr) return tree[node];
    else
    {
        int mid = (l+r) >> 1;
        if(ql > mid)          return Query(mid+1 , r , (node<<1)+1);
        else if(qr <= mid)    return Query(l , mid , node<<1);
        else                  return max(Query(l , mid , node<<1) , Query(mid+1 , r , (node<<1)+1));
    }
}

5，线段树区间修改（修改使区间每个点增加值，询问区间和）

ll  tree[4*maxn] , a[maxn] , lazy[maxn];
int ql = 0, qr = 0 , add = 0;

void BuildTree(int l,int r,int node)
{
    if(l == r) tree[node] = a[l];
    else
    {
        int mid = (l + r) >> 1;
        BuildTree(l, mid , node<<1);
        BuildTree(mid+1 , r , (node<<1)+1);
        tree[node] = tree[node<<1] + tree[(node<<1)+1];
    }
}

void pushdown(int node , int l)
{
    if(lazy[node])
    {
        lazy[node<<1] +=  lazy[node];              lazy[node<<1|1] += lazy[node];
        tree[node<<1] += lazy[node] * (l-(l>>1));  tree[node<<1|1] += lazy[node] * (l>>1);
        lazy[node] = 0;
    }
}

void UpdateTree(int l ,int r, int node)
{
    if(ql <= l && qr >= r)
    {
        tree[node] += add * (r-l+1);
        lazy[node] += add;
    }
    else
    {
        pushdown(node,r-l+1);
        int mid = (l+r) >> 1;
        if(qr > mid)     UpdateTree(mid+1 , r , node<<1|1);
        if(ql <= mid)    UpdateTree(l , mid , node<<1);
        tree[node] = tree[node<<1] + tree[node<<1|1];
    }
}

ll Query(int l , int r ,int node)
{
    pushdown(node , r - l + 1);
    if(l >= ql && r <= qr) return tree[node];
    else
    {
        int mid = (l+r) >> 1;
        if(ql > mid)          return Query(mid+1 , r , (node<<1)+1);
        else if(qr <= mid)    return Query(l , mid , node<<1);
        else                  return Query(l , mid , node<<1) + Query(mid+1 , r , (node<<1)+1);
    }
}

 

6，线段树区间合并（hud3911 Black And White ，区间修改所有颜色成相反色，询问区间黑色最大连续长度）

struct Node
{
    int left , right , len , lazy;
    int max_pre_0 , max_suf_0 , max_sub_0;
    int max_pre_1 , max_suf_1 , max_sub_1;
}tree[maxn<<2];

void PushUp(int node)
{
    tree[node].max_pre_0 = tree[node<<1].max_pre_0;
    tree[node].max_suf_0  = tree[node<<1|1].max_suf_0;
    if(tree[node<<1].max_pre_0 == tree[node<<1].len)      tree[node].max_pre_0 += tree[node<<1|1].max_pre_0;
    if(tree[node<<1|1].max_suf_0 == tree[node<<1|1].len)  tree[node].max_suf_0 += tree[node<<1].max_suf_0;
    tree[node].max_sub_0 = max( max(tree[node<<1].max_sub_0 , tree[node<<1|1].max_sub_0) , tree[node<<1].max_suf_0+tree[node<<1|1].max_pre_0);

    tree[node].max_pre_1 = tree[node<<1].max_pre_1;
    tree[node].max_suf_1 = tree[node<<1|1].max_suf_1;
    if(tree[node<<1].max_pre_1 == tree[node<<1].len)      tree[node].max_pre_1 += tree[node<<1|1].max_pre_1;
    if(tree[node<<1|1].max_suf_1 == tree[node<<1|1].len)  tree[node].max_suf_1 += tree[node<<1].max_suf_1;
    tree[node].max_sub_1 = max( max(tree[node<<1].max_sub_1 , tree[node<<1|1].max_sub_1) , tree[node<<1].max_suf_1+tree[node<<1|1].max_pre_1);
}

void BuildTree(int left, int right, int node)
{
    tree[node] = {left, right, right-left+1, 0};
    if(left == right )
    {
        int x; scanf("%d",&x);
        tree[node].max_pre_0 = tree[node].max_suf_0 = tree[node].max_sub_0 = (x ? 0 : 1);
        tree[node].max_pre_1 = tree[node].max_suf_1 = tree[node].max_sub_1 = (x ? 1 : 0);
        return ;
    }
    int mid = (left + right) >> 1;
    BuildTree(left,mid,node<<1);    BuildTree(mid+1,right,node<<1|1);
    PushUp(node);
}


void Change(int node)
{
    swap(tree[node].max_pre_0, tree[node].max_pre_1);
    swap(tree[node].max_suf_0, tree[node].max_suf_1);
    swap(tree[node].max_sub_0, tree[node].max_sub_1);
    tree[node].lazy ^= 1;
}

void PushDown(int node)
{
    if(tree[node].lazy)
    {
        Change(node<<1); Change(node<<1|1);
        tree[node].lazy = 0;
    }
}

void UpdateTree(int left , int right , int node)
{
    if(left <= tree[node].left && right >= tree[node].right)
    {
        Change(node); return ;
    }

    PushDown(node);
    int mid = (tree[node].left + tree[node].right) >> 1;
    if(right > mid)        UpdateTree(left, right, node<<1|1);
    if(left <= mid)        UpdateTree(left, right, node<<1);
    PushUp(node);
}

int Query(int left , int right , int node )
{
    if(left <= tree[node].left && right >= tree[node].right) return tree[node].max_sub_1;

    PushDown(node);
    int mid = (tree[node].left + tree[node].right) >> 1;
    if(left > mid)         return Query(left, right, node<<1|1);
    else if(right <= mid)  return Query(left, right, node<<1);
    else
    {
        int max_ans1 =  max(Query(left, mid, node<<1) , Query(mid+1, right, node<<1|1));
        int max_ans2 =  min(mid-left+1,tree[node<<1].max_suf_1) + min(right-mid,tree[node<<1|1].max_pre_1);
        return max( max_ans1, max_ans2 );
    }
}