线段树完全版【代码集合

可能有些题要重写，先放这么多

单点更新

1.hdu1166 敌兵布阵

#include <stdio.h>
#define maxn 200000
#include <algorithm>
using namespace std;
int qr, ql, v, x, l, n, ans;
int tree[maxn];
void build(int o, int l,int r) {
    if (l == r) {
        scanf("%d",&tree[o]);
        return ;
    }
    int mid = (l + r) >> 1;
    build(o*2, l, mid);
    build(o*2+1, mid+1, r);
    tree[o] = tree[o*2] + tree[o*2+1];
}
void update(int o, int l, int r)
{
    if (l == r)
        {tree[o] += v;return;}
    int mid = (l + r) >> 1;
    if(x > mid)update(o*2+1, mid+1, r);
    else update(o*2, l, mid);
    tree[o] = tree[o*2] + tree[o*2+1];
}
void query(int o, int l, int r)
{
    if(l >= ql && qr >= r)
    {
        ans += tree[o];return ;
    }
    int mid = (l + r) >> 1;
    if(mid >= ql)query(o*2, l, mid);
    if(mid < qr)query(o*2+1, mid+1, r);
}
int main()
{
    int T;
    scanf("%d", &T);
    for (int cas = 1 ; cas <= T ; cas ++) 
    {
        printf("Case %d:\n",cas);
        scanf("%d",&n);
        build(1, 1, n);
        char s[10];
        while(scanf("%s",s))
        {
            if(s[0] == 'E')break;
            if(s[0] == 'A')
            {
                scanf("%d %d", &x, &v);
                update(1, 1, n);
            }
            if(s[0] == 'S')
            {
                scanf("%d %d", &x, &v);
                v = -v;update(1, 1, n);
            }
            if(s[0] == 'Q')
            {
                scanf("%d %d", &ql, &qr);
                ans = 0;
                query(1, 1, n);
                printf("%d\n", ans);
            }
        }
    }
}

2.hdu1754 I Hate It

#include <stdio.h>
#include <algorithm>
#define maxn 222222
using namespace std;
int n, m, tree[maxn<<2];
void build(int o, int l ,int r)
{
    if(l == r){
        scanf("%d", &tree[o]);
        return ;
    }   
    int mid = (l + r) >> 1;
    build(o<<1, l, mid);
    build(o<<1|1, mid+1, r);
    tree[o] = max(tree[o<<1], tree[o<<1|1]);
}
void update(int x, int v, int o, int l, int r)
{
    if(l == r)
    {
        tree[o] = v;
        return;
    }
    int mid = (l + r) >> 1;
    if(x <= mid)update(x, v, o * 2, l, mid);
    else update(x, v, o*2+1, mid+1, r);
    tree[o] = max(tree[o<<1], tree[o<<1|1]);
}
int query(int ql, int qr, int o, int l, int r)
{
    if (ql <= l&& r <= qr)
        {
            return tree[o];
        }
    int ans = 0;
    int mid = (l + r) >> 1;
    if(ql <= mid)ans = max(ans, query(ql, qr, o<<1, l, mid));
    if(qr > mid)ans = max(ans, query(ql, qr, o<<1|1, mid+1, r));//ans = max(ans, query(ql, qr, o*2, l, mid));
    return ans;
}
int main()
{
    while(~scanf("%d %d", &n, &m))
    {
        build(1, 1, n);
        while(m--)
        {
            char s[20];
            int a, b;
            //ans = 0;
            scanf("%s %d %d", s, &a, &b);
            if(s[0] == 'Q')
               printf("%d\n", query(a, b, 1, 1, n));
            else update(a, b, 1, 1, n);
        }
    }
    return 0;
}

3.hdu1394 Minimum Inversion Number

#include <stdio.h>
#define maxn 6000
#include <string.h>
#include <algorithm>
using namespace std;
int an, x[maxn<<2], sum, n, tree[maxn << 2];
void update(int X, int o, int l, int r)
{
    if(l == r)
    {
        tree[o]++;
        return;
    }
    int mid = (l + r) >> 1;
    if (X > mid)update(X, o<<1|1, mid+1, r);
    else update(X, o<<1, l, mid);
    tree[o] = tree[o<<1] + tree[o<<1|1];
}
int query(int ql, int qr, int o, int l, int r)
{
    if(ql <= l&&r <= qr)
    {
        return tree[o];
    }
    int mid = (l + r) >> 1;
    int ans = 0;
    if(ql <= mid)ans += query(ql, qr, o<<1, l, mid);
    if(qr > mid)ans += query(ql, qr, o<<1|1, mid+1, r);
    return ans;
}
int main()
{
    while(~scanf("%d", &n))
    {
        an = 2000000000; sum = 0;
        memset(tree, 0, sizeof(tree));
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &x[i]);
        x[i]++;
        sum += query(x[i]+1, n, 1, 1, n);
        update(x[i], 1, 1, n);
    }
    for (int i = n; i >= 1; i--)
    {
        sum = sum + (x[i]-1) - (n-x[i]);  
        // da n - (x[i])
        // xiao x[i]-1
        // sum = sum + x[i] - 1 - n + x[i] ; 
        an = min (an, sum); 
    }
    printf("%d\n", an);
}
}

 

4.hdu2795 Billboard

#include <stdio.h>
#include <string.h>
#include <algorithm>
#define maxn 200010
using namespace std;
int tree[maxn<<2], h, w, n, sum;
void build(int o, int l, int r)
{
    tree[o] = w;
    if(l == r)return;
    int mid = (l + r) >> 1;
    build(o<<1, l, mid);
    build(o<<1|1, mid+1, r);
}
int query(int a, int o, int l, int r)
{
    if (l == r)
    {
        tree[o] -= a;
        return l;
    }
    int mid = (l + r) >> 1;
    if (a <= tree[o<<1])sum = query(a, o<<1, l, mid);
    else sum = query(a, o<<1|1, mid+1, r);
    tree[o] = max(tree[o<<1], tree[o<<1|1]);
    return sum;
}
int main()
{
    while (~scanf("%d %d %d", &h, &w, &n))
    {
        if (h > n)h = n;
        build(1, 1, h);
        while (n--)
        {
            int a;
            scanf("%d", &a);
            if(tree[1] < a)printf("-1\n");
            else printf("%d\n", query(a, 1, 1, h));
        }
    }
}

5.poj2828 Buy Tickets

#include <stdio.h>
#include <string.h>
#include <algorithm>
#define maxn 200010
using namespace std;
int tree[maxn<<2], h, w, n, sum;
int p[maxn], v[maxn], ans[maxn];
void build(int o, int l, int r)
{
    if(l == r){tree[o] = 1;return;}
    int mid = (l + r) >> 1;
    build(o<<1, l, mid);
    build(o<<1|1, mid+1, r);
    tree[o] = tree[o<<1] + tree[o<<1|1];
}
void query(int x, int v, int o, int l, int r)
{
    if (l == r)
    {
        ans[l] = v;
        tree[o] = 0;
        return;
    }
    int mid = (l + r) >> 1;
    if (x <= tree[o<<1])query(x, v, o<<1, l, mid);
    else query(x - tree[o<<1], v, o<<1|1, mid+1, r);
    tree[o] = tree[o<<1] + tree[o<<1|1];
}
int main()
{
    while (scanf("%d", &n)!=EOF)
    {
        build(1, 1, n);
        for(int i = 1; i <= n; i++)
            scanf("%d %d", &p[i], &v[i]);
        for(int i = n; i > 0; i--)
            query(p[i]+1, v[i], 1, 1, n);
        for(int i = 1; i <= n; i++)
            printf("%d ", ans[i]);
        printf("\n");
    }
    return 0;
}

6.poj2886 Who Gets the Most Candies?

#include <stdio.h>
#include <string.h>
#define maxn 500010
#include <algorithm>
using namespace std;
int tree[maxn<<2], maxx, ans[maxn];
int pos, mod, id, x[maxn], n, k;
char name[maxn][20];
void build(int o, int l, int r)
{
    if (l == r)
    {
        tree[o] = 1;
        return ;
    }
    int mid = (l + r) >> 1;
    build(o<<1, l, mid);
    build(o<<1|1, mid+1, r);
    tree[o] = tree[o<<1] + tree[o<<1|1];
}
int update(int k, int o, int l, int r)
{
    tree[o]--;
    if(l == r){return l;}
    int mid = (l + r) >> 1;
    if (k <= tree[o<<1])
         return  update(k, o<<1, l, mid);
    else  return   update(k - tree[o<<1], o<<1|1, mid+1, r);
}
/*int update(int p, int o, int l,int r)
{
    tree[o]--;
    if(l==r)
         return r;
    int m=(l+r)>>1;
    if(p<=tree[o<<1])
         return update(k,o<<1,l,m);
    return update(k-tree[o<<1],o<<1|1, m+1,r);
}*/
void getans()
{
    memset(ans, 0, sizeof(ans));
    for (int i = 1; i <= n; i++)
    {
        ans[i]++;
        for (int j = 2 * i; j <= n; j+=i)
            ans[j]++;
    }
    int maxx = ans[1];
    id = 1;
    for (int i = 2; i <= n; i++)
    {
        if(ans[i] > maxx)
        {
            maxx = ans[i];
            id = i;
        }
    }
}
int main()
{
    while(~scanf("%d %d", &n, &k))
    {
        getans();
        build(1, 1, n);
        int N = n;
        for (int i = 1; i <= n; i++)
        {
            scanf("%s %d", name[i], &x[i]);
        }
        pos = 0, n = id, x[0] = 0, mod = tree[1];
        while(n--)
        {
            if(x[pos] > 0)
                k = ((k - 1 + x[pos] - 1)%mod + mod)%mod + 1;
            else 
                k = ((k + x[pos] - 1)%mod + mod)%mod + 1;
            pos = update(k, 1, 1, N);
            mod = tree[1];
        }
        printf("%s %d\n", name[pos], ans[id]);
    }
}

成段更新

1.hdu1698 Just a Hook

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

#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
const int maxn=100002;
int col[maxn<<2];//用来标记每个节点，为0则表示没有标记，否则为标记，以颜色的价值作为标记。
int sum[maxn<<2];//求和

void PushUp(int rt)//向上更新和
{
  sum[rt]=sum[rt<<1]+sum[rt<<1|1];
}

void PushDown(int rt,int m)//对某一个区间进行改变，如果被标记了，在查询的时候就得把改变传给子节点，因为查询的并不一定是当前区间
{//m为区间长度
  if(col[rt])//已经标记过，该区间被改变过
  {
    col[rt<<1]=col[rt<<1|1]=col[rt];//标记子节点
    sum[rt<<1]=(m-(m>>1))*col[rt];//更新左儿子的和
    sum[rt<<1|1]=(m>>1)*col[rt];//更新右儿子的和
    col[rt]=0;
  }
}

void build(int l,int r,int rt)
{
  col[rt]=0;//初始化为所有节点均未标记
  sum[rt]=1;//初始值为1
  if(l==r)
    return;
  int m=(l+r)>>1;
  build(lson);
  build(rson);
}

void update(int L,int R,int c,int l,int r,int rt)
{
  if(L<=l&&r<=R)
  {
    col[rt]=c;
    sum[rt]=c*(r-l+1);//更新代表某个区间的节点和，该节点不一定是叶子节点
    return ;
  }
  PushDown(rt,r-l+1);//向下传递
  int m=(l+r)>>1;
  if(L<=m)
    update(L,R,c,lson);//更新左儿子
  if(R>m)
    update(L,R,c,rson);//更新右儿子
  PushUp(rt);//向上传递更新和
}
int main()
{
  int k;cin>>k;
  int n,c,add,a,b;
  for(int i=1;i<=k;i++)
  {
    scanf("%d",&n);
    build(1,n,1);
    scanf("%d",&c);
    for(int j=1;j<=c;j++)
    {
      scanf("%d%d%d",&a,&b,&add);
      update(a,b,add,1,n,1);
    }
    printf("Case %d: The total value of the hook is %d.\n",i,sum[1]);
  }
  return 0;
}

2.poj3468 A Simple Problem with Integers

#include <stdio.h>
#include <string.h>
#define maxn 100010
#include <algorithm>
using namespace std;
long long lazy[maxn<<2], tree[maxn<<2], N, Q;
void build (long long o, long long l,long long r)
{
    lazy[o] = 0;
    if(l == r){scanf("%I64d", &tree[o]);return;}
    int mid = (l+r)>>1;
    build(o<<1, l, mid);
    build(o<<1|1, mid+1, r);
    tree[o] = tree[o<<1] + tree[o<<1|1];
}
void pushdown(long long o, long long x)
{
    if (lazy[o])
    {
        lazy[o<<1] += lazy[o];
        lazy[o<<1|1] += lazy[o];
        tree[o<<1] += (x-(x>>1))*lazy[o];
        tree[o<<1|1] += (x>>1)*lazy[o];
        lazy[o] = 0;
    }
}
void update(long long ql, long long qr, long long v, long long o, long long l,  long long r)
{
    if(ql <= l&&r <= qr)
    {
        lazy[o] += v;
        tree[o] += (long long )v * (r - l + 1);
        return;
    }
    pushdown(o, r - l + 1);
    int mid = (l+r)>>1;
    if(ql <= mid)update(ql, qr, v, o<<1, l, mid);
    if(qr > mid)update(ql, qr, v, o<<1|1, mid+1, r);
    tree[o] = tree[o<<1] + tree[o<<1|1];
}
long long query(long long ql, long long qr, long long o, long long l,  long long r)
{
    if(ql <= l&&r <= qr)
    {
        return tree[o];
    }
    pushdown(o, r - l + 1);
    long long mid = (l+r)>>1;
    long long ans = 0;
    if(ql <= mid)ans += query(ql, qr, o<<1, l, mid);
    if(qr > mid)ans += query(ql, qr, o<<1|1, mid+1, r);
    return ans;
}
int main()
{
    scanf("%I64d%I64d", &N, &Q);
        build(1, 1, N);
        while (Q--)
        {
            char s[50];
            long long a, b, c;
            scanf("%s", s);
            if (s[0] == 'Q')
                {
                    scanf("%I64d %I64d", &a, &b);
                    printf("%lld\n", query(a,b,1,1,N));
                }
            else {
                scanf("%I64d%I64d%I64d", &a, &b, &c);
                update(a, b, c, 1, 1, N);
            }    
        }
    return 0;
}

3.poj2528 Mayor’s posters

#include <stdio.h>
#include <string.h>
#define maxn 100010
#include <algorithm>
using namespace std;
int lazy[maxn<<2], vis[maxn<<2], n, x[maxn], y[maxn], X[maxn];
int tot, cnt, m;
void pushdown(int o)
{
    if(lazy[o] != -1)
    {
        lazy[o<<1] = lazy[o<<1|1] = lazy[o];        
        lazy[o] = -1;
    }    
}
void update(int ql, int qr, int v, int o, int l, int r)
{
    if(ql <= l&&r <= qr)        
    {
        lazy[o] = v;
        return;
        }
    pushdown(o);
    int mid = (l + r)>>1;    
    if(ql <= mid)update(ql, qr, v, o<<1, l, mid);
    if(qr > mid)update(ql, qr, v, o<<1|1, mid+1, r);
}
void query(int o, int l, int r)
{
    if(lazy[o] != -1)
    {if(!vis[lazy[o]])cnt++;
    vis[lazy[o]] = 1;return;}
    int mid = (l + r) >> 1;
    if(l == r)return;
    query(o<<1, l, mid);
    query(o<<1|1, mid+1, r);
}
int erfen(int key, int m, int *a) 
{
    int l = 1, r = m;
    while(l <= r)
    {
        int mid = (l + r) >> 1;
        if(a[mid] == key) return mid;
        if(a[mid] < key)l = mid+1;
        else r = mid - 1;
    }
    return -1;
}
int main()
{
    int T;
    scanf("%d", &T);
    tot = 0;
    while(T--)
    {
        tot = 0;
        m = 0;
        scanf("%d", &n);
        for (int i = 1; i <= n; i++)
            {
                scanf("%d %d", &x[i], &y[i]);
                X[++tot] = x[i];
                X[++tot] = y[i];
            }
        memset(lazy, -1, sizeof(lazy));
            sort(X+1, X+1+tot);
        for(int i = 1; i <= tot; i++)
            if(X[i] != X[i-1])    
                    X[++m] = X[i];
        for(int i = m; i >= 1; i--)
        {
            if(X[i] != 1 + X[i-1])X[++m] = X[i-1] + 1;
        }
        sort(X+1, X+1+m);
        for (int i = 1; i <= n; i++)
        {
        int    l = erfen(x[i], m, X);        
        int    r = erfen(y[i], m, X);
            update(l, r, i, 1, 1, m);
        }
        cnt = 0;
        memset(vis, 0, sizeof(vis));
        query(1, 1, m);
        printf("%d\n", cnt);
    }
}

4.poj3225 Help with Intervals

#include <stdio.h>
#include <algorithm>
#define maxn 150000
using namespace std;
int xorv[maxn<<2], setv[maxn<<2], L, R, val[maxn+10];
char kase, kl, kr;
void xorit(int o)
{
    if (setv[o] != -1)setv[o] ^= 1;
    else xorv[o]^=1;
}
void pushdown(int o)
{
    int lc = o*2, rc = o * 2 + 1;
    if (setv[o] != -1)
    {
        setv[lc] = setv[rc] = setv[o];
        xorv[lc] = xorv[rc] = 0;
        setv[o] = -1;
    }
    if (xorv[o])
    {
        xorit(lc);xorit(rc);xorv[o]=0;
    }
}
void update(int o, int l, int r)
{
    //int lc = o *2, rc = o *2 + 1;
    if (L <= l && R >= r)
    {
        if (kase == 'U')setv[o] = 1,xorv[o] = 0;
        else if (kase == 'D')setv[o] = xorv[o] = 0;
        else if (kase == 'C'||kase == 'S')xorit(o);
    }
    else {
        pushdown(o);
        int mid =  (r + l)/2;
        if (L <= mid)update(o * 2, l, mid);
        else if (kase == 'I'||kase=='C')setv[o*2] = xorv[o*2] = 0;
        if (R > mid)update(o *2 +1, mid + 1,  r);
        else if (kase == 'I'||kase=='C')setv[o*2+1] = xorv[o*2+1] = 0;
    }
}
void suckit(int o, int l, int r)
{
    if (setv[o] == 1)
    {
        for (int i = l; i <= r; i++)
            val[i] = 1;
        return ;
    }
    else if (!setv[o] || l == r)return ;
    int mid = (l + r)/2;
    pushdown(o);
    suckit(o*2, l, mid);
    suckit(o*2+1, mid +1, r);
}
void print()
{
    int l = -1,r, find =0;
    for (int i = 0; i <= maxn;i++)
    {
        if (val[i]){if(l==-1)l=i;r=i;}
        else if(~l){
            if(find)putchar(' ');find = 1;
            printf("%c%d,%d%c",l&1 ? '(' : '[',l >> 1,(r+1)>>1,r&1 ? ')' : ']');
            l = -1;
        }
    }
    if (!find)printf("empty set");
    else puts("");
}
int main() {
  while (~scanf("%c %c%d,%d%c\n", &kase, &kl, &L, &R, &kr)) {
    L <<= 1; if (kl == '(') L++;
    R <<= 1; if (kr == ')') R--;
    if (L > R) { if (kase == 'I' || kase == 'C') xorv[1] = setv[1] = 0; }
    else update(1, 0, maxn);
  }
  suckit(1, 0, maxn);
  print();
  return 0;
}

5.poj1436 Horizontally Visible Segments

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
int n, y1, y2, x, T, nn;
bool map[8010][8010];
struct node{
    int l, r, x;
}a[8010<<1];
int colo[8010<<3];
int cmp(node a, node b)
{
    return a.x < b.x;    
}
void pushdown(int o)
{
    if (colo[o])
    {
        colo[o<<1] = colo[o<<1|1] = colo[o];
        colo[o] = 0;
    }
}
void update(int ql, int qr, int x, int o, int l, int r)
{
    if(ql <=l &&r <= qr)
    {
        colo[o] = x;return ;
    }
    pushdown(o);
    int mid = (l + r) >>1;
    if(ql <= mid)update(ql, qr, x, o<<1, l, mid);
    if(qr > mid)update(ql, qr, x, o<<1|1, mid+1, r);
}
void query(int ql, int qr, int x, int o, int l, int r)
{
    if(colo[o])
    { 
        map[x][colo[o]] = 1;
        return ;
    }
    if (l == r)return ;
    int mid = (l + r) >> 1;
    if(ql <= mid)query(ql, qr, x, o<<1, l ,mid);
    if(qr > mid)query(ql, qr, x, o<<1|1, mid+1, r);
}
int main()
{
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d", &n);
        for(int i = 1; i <= n; i++)
        {
            scanf("%d %d %d", &y1, &y2, &x);            
            y1<<=1;y2<<=1;
            a[i].l = y1;a[i].r = y2;a[i].x = x;
        }
        sort(a+1, a+1+n, cmp);
        memset(map, 0, sizeof(map));
        memset(colo, 0, sizeof(colo));
        for(int i = 1; i <= n; i++)
        {
            query(a[i].l, a[i].r, i, 1, 0, 8001<<1);
            update(a[i].l, a[i].r, i, 1, 0, 8001<<1);
        }
        int ans = 0;
        for (int i = 1; i<= n; i++)
            for (int j = 1; j <= n; j++)
                if(map[i][j])
                    for(int k = 1; k <= n; k++)
                    {
                        if(map[i][k]&&map[j][k])
                                ans++;
                    }
        printf("%d\n", ans);    
    }
}

6.poj2991 Crane

#include<stdio.h>
#include<string.h>
#include<math.h>
#define MAXD 10010
const double PI = acos(-1.0);
int N, M, a[MAXD], A[MAXD], degree[MAXD], rd[4 * MAXD];
struct point
{
    double x, y;
}dp[4 * MAXD];
double getrad(int x)
{
    return x * PI / 180;
}
void build(int cur, int x, int y)
{
    int mid = (x + y) >> 1, ls = cur << 1, rs = (cur << 1) | 1;
    rd[cur] = 0;
    dp[cur].x = 0, dp[cur].y = A[y] - A[x - 1];
    if(x == y)
        return ;
    build(ls, x, mid);
    build(rs, mid + 1, y);
}
void init()
{
    int i;
    A[0] = 0;
    for(i = 1; i <= N; i ++)
    {
        scanf("%d", &a[i]);
        A[i] = A[i - 1] + a[i];
        degree[i] = 0;
    }
    build(1, 1, N);
}
void update(int cur)
{
    int ls = cur << 1, rs = (cur << 1) | 1;
    dp[cur].x = dp[ls].x + dp[rs].x, dp[cur].y = dp[ls].y + dp[rs].y;
}
void Rotate(double &dx, double &dy, double rad)
{
    double x = dx, y = dy;
    dx = x * cos(rad) - y * sin(rad);
    dy = x * sin(rad) + y * cos(rad);
}
void pushdown(int cur)
{
    int ls = cur << 1, rs = (cur << 1) | 1;
    if(rd[cur])
    {
        double rad = getrad(rd[cur]);
        rd[ls] += rd[cur], rd[rs] += rd[cur];
        Rotate(dp[ls].x, dp[ls].y, rad);
        Rotate(dp[rs].x, dp[rs].y, rad);
        rd[cur] = 0;
    }
}
void refresh(int cur, int x, int y, int k, int delta)
{
    int mid = (x + y) >> 1, ls = cur << 1, rs = (cur << 1) | 1;
    if(x == y)
    {
        double rad = getrad(delta);
        Rotate(dp[cur].x, dp[cur].y, rad);
        return ;
    }
    pushdown(cur);
    if(mid + 1 < k)
        refresh(rs, mid + 1, y, k, delta);
    else
    {
        double rad = getrad(delta);
        if(k <= mid)
            refresh(ls, x, mid, k, delta);
        Rotate(dp[rs].x, dp[rs].y, rad);
        rd[rs] += delta;
    }
    update(cur);
}
void solve()
{
    int i, j, k, d, delta;
    for(i = 0; i < M; i ++)
    {
        scanf("%d%d", &k, &d);
        ++ k, d = d - 180;
        delta = d - degree[k];
        degree[k] = d;
        refresh(1, 1, N, k, delta);
        printf("%.2f %.2f\n", dp[1].x, dp[1].y);
    }
}
int main()
{
    int t = 0;
    while(scanf("%d%d", &N, &M) == 2)
    {
        init();
        if(t ++)
            printf("\n");
        solve();
    }
    return 0;
}

区间合并

1.poj3667 Hotel  【重写预定

#include <cstdio>
#include <cstring>
#include <cctype>
#include <algorithm>
using namespace std;
#define lson l , m , rt << 1
#define rson m + 1 , r , rt << 1 | 1
const int maxn = 55555;
int lsum[maxn<<2] , rsum[maxn<<2] , msum[maxn<<2];
int cover[maxn<<2];
void PushDown(int rt,int m) {
    if (cover[rt] != -1) {
        cover[rt<<1] = cover[rt<<1|1] = cover[rt];
        msum[rt<<1] = lsum[rt<<1] = rsum[rt<<1] = cover[rt] ? 0 : m - (m >> 1);
        msum[rt<<1|1] = lsum[rt<<1|1] = rsum[rt<<1|1] = cover[rt] ? 0 : (m >> 1);
        cover[rt] = -1;
    }
}
void PushUp(int rt,int m) {
    lsum[rt] = lsum[rt<<1];
    rsum[rt] = rsum[rt<<1|1];
    if (lsum[rt] == m - (m >> 1)) lsum[rt] += lsum[rt<<1|1];
    if (rsum[rt] == (m >> 1)) rsum[rt] += rsum[rt<<1];
    msum[rt] = max(lsum[rt<<1|1] + rsum[rt<<1] , max(msum[rt<<1] , msum[rt<<1|1]));
}
void build(int l,int r,int rt) {
    msum[rt] = lsum[rt] = rsum[rt] = r - l + 1;
    cover[rt] = -1;
    if (l == r) return ;
    int m = (l + r) >> 1;
    build(lson);
    build(rson);
}
void update(int L,int R,int c,int l,int r,int rt) {
    if (L <= l && r <= R) {
        msum[rt] = lsum[rt] = rsum[rt] = c ? 0 : r - l + 1;
        cover[rt] = c;
        return ;
    }
    PushDown(rt , r - l + 1);
    int m = (l + r) >> 1;
    if (L <= m) update(L , R , c , lson);
    if (m < R) update(L , R , c , rson);
    PushUp(rt , r - l + 1);
}
int query(int w,int l,int r,int rt) {
    if (l == r) return l;
    PushDown(rt , r - l + 1);
    int m = (l + r) >> 1;
    if (msum[rt<<1] >= w) return query(w , lson);
    else if (rsum[rt<<1] + lsum[rt<<1|1] >= w) return m - rsum[rt<<1] + 1;
    return query(w , rson);
}
int main() {
    int n , m;
    scanf("%d%d",&n,&m);
    build(1 , n , 1);
    while (m --) {
        int op , a , b;
        scanf("%d",&op);
        if (op == 1) {
            scanf("%d",&a);
            if (msum[1] < a) puts("0");
            else {
                int p = query(a , 1 , n , 1);
                printf("%d\n",p);
                update(p , p + a - 1 , 1 , 1 , n , 1);
            }
        } else {
            scanf("%d%d",&a,&b);
            update(a , a + b - 1 , 0 , 1 , n , 1);
        }
    }
    return 0;
}

2.hdu3308 LCIS

#include <stdio.h>
#include <string.h>
#define maxn 100010
#include <algorithm>
using namespace std;
int lsum[maxn<<2], rsum[maxn<<2], ssum[maxn<<2], num[maxn];
int T, n, q, a, b;
void pushup(int o, int m, int l, int r)
{
    int mid = (l + r) >> 1;
    lsum[o] = lsum[o<<1];
    rsum[o] = rsum[o<<1|1];
    ssum[o] = max(ssum[o<<1], ssum[o<<1|1]);
    if(num[mid] < num[mid+1])
    {
        if(lsum[o] == m-(m>>1))lsum[o]+=lsum[o<<1|1];
        if(rsum[o] == (m>>1))rsum[o]+=rsum[o<<1];
        ssum[o] = max(lsum[o<<1|1]+rsum[o<<1], ssum[o]);
    }
}

void build(int o, int l, int r)
{
    //lsum[o] = rsum[o] = ssum[o] = r - l + 1;
    if(l == r)
    {
        scanf("%d", &num[l]);
        lsum[o] = rsum[o] = ssum[o] = 1;
        return ;
    }
    int mid = (l + r) >> 1;
    build(o<<1, l, mid);
    build(o<<1|1, mid+1, r);
    pushup(o,r-l+1,l, r);
}
void update(int p, int v, int o, int l, int r)
{
    if(l == r)
    {
            num[l] = v;
            return;
    }
    int mid = (l + r) >> 1;
    if(p <= mid)update(p, v, o<<1, l, mid);
    else if(p > mid)update(p, v, o<<1|1, mid+1, r);
    pushup(o, r-l+1, l, r);
}
int query(int ql, int qr, int o, int l, int r)
{
    if(ql <= l&& r <= qr)
        return ssum[o];
    int mid = (l + r) >> 1;
    int ans = 0;
    if(ql <= mid)ans = max(ans,query(ql, qr, o<<1, l, mid));
    if(qr > mid)ans = max(ans, query(ql, qr, o<<1|1, mid+1, r));
    if(num[mid] < num[mid+1])
        ans = max(ans, min(mid-ql+1, rsum[o<<1]) + min(qr-mid, lsum[o<<1|1]));
    return ans;
}
int main()
{
    char s[5];
    scanf("%d", &T);
    while (T--)
    {
        scanf("%d %d", &n, &q);
        build(1, 1, n);
        //for (int i = 1; i <= n; i++)scanf("%d", &num[i]);
        while(q--)
        {
            scanf("%s %d %d", s, &a, &b);
            if(s[0] == 'Q')
                printf("%d\n", query(a+1,b+1,1,1,n));
            else update(a+1,b,1,1,n);
        }
    }
}

3.hdu3397 Sequence operation  【重写预定

#include <stdio.h>
#define maxn 100010
#include <algorithm>
using namespace std;
struct node{
    int sum, v0, v1, left0, left1;
    int right0, right1;
}tree[maxn<<2];
int lazy[maxn<<2], cover[maxn<<2];
int n;
void pushup(int mid, int o, int l, int r)
{
    tree[o].sum=tree[o<<1].sum+tree[o<<1|1].sum;
    tree[o].left0=tree[o<<1].left0;
    tree[o].right0=tree[o<<1|1].right0;
    tree[o].left1=tree[o<<1].left1;
    tree[o].right1=tree[o<<1|1].right1;
    if(tree[o].left0==mid-l+1)
            tree[o].left0+=tree[o<<1|1].left0;
    if(tree[o].left1==mid-l+1)
            tree[o].left1+=tree[o<<1|1].left1;
    if(tree[o].right0==r-mid)
            tree[o].right0+=tree[o<<1].right0;
    if(tree[o].right1==r-mid)
            tree[o].right1+=tree[o<<1].right1;
    tree[o].v0=max(tree[o<<1].v0, tree[o<<1|1].v0);
    tree[o].v0=max(tree[o].v0,tree[o<<1].right0+tree[o<<1|1].left0);
    tree[o].v1=max(tree[o<<1].v1, tree[o<<1|1].v1);
    tree[o].v1=max(tree[o].v1,tree[o<<1].right1+tree[o<<1|1].left1);
}
void fxor(int o, int l, int r)
{
    if(cover[o]!=-1)
    {
        cover[o]^=1;
        tree[o].left1=tree[o].right1=tree[o].v1=tree[o].sum=(r-l+1)*cover[o];
        tree[o].left0=tree[o].right0=tree[o].v0=(r-l+1)*(cover[o]^1);
    }
    else {
        lazy[o]^=1;
        tree[o].sum=r-l+1 - tree[o].sum;
        swap(tree[o].left0, tree[o].left1);
        swap(tree[o].right0, tree[o].right1);
        swap(tree[o].v0, tree[o].v1);
    }
}
void pushdown(int mid, int o, int l, int r)
{
    if(cover[o] != -1)
    {
        cover[o<<1]=cover[o<<1|1]=cover[o];
        lazy[o<<1]=lazy[o<<1|1]=0;
        tree[o<<1].left1=tree[o<<1].right1=tree[o<<1].v1=tree[o<<1].sum=(mid-l+1)*cover[o];
        tree[o<<1|1].left1=tree[o<<1|1].right1=tree[o<<1|1].v1=tree[o<<1|1].sum=(r-mid)*cover[o];
        tree[o<<1].left0=tree[o<<1].right0=tree[o<<1].v0=(mid-l+1)*(cover[o]^1);
        tree[o<<1|1].left0=tree[o<<1|1].right0=tree[o<<1|1].v0=(r-mid)*(cover[o]^1);
        cover[o]=-1;
    }
    if(lazy[o])
    {
        fxor(o<<1, l, mid);
        fxor(o<<1|1, mid+1, r);
        lazy[o] = 0;
    }
}
void build(int o, int l, int r)
{
    cover[o] = -1;
    lazy[o] = 0;
    if(l == r)
    {
        scanf("%d", &tree[o].sum);
        tree[o].v1=tree[o].left1=tree[o].right1=tree[o].sum;
        tree[o].v0=tree[o].left0=tree[o].right0=tree[o].sum^1;
    }
    else {int mid = (l + r)>>1;
    build(o<<1, l, mid);
    build(o<<1|1, mid+1, r);
    pushup(mid, o, l, r);
    }
}
void update(int ql, int qr, int v, int o, int l, int r)
{
    if(ql <= l&& r <= qr)
    {
        cover[o] = v;
        lazy[o]=0;
        tree[o].left1=tree[o].right1=tree[o].sum=tree[o].v1=(r-l+1)*v;
        tree[o].left0=tree[o].right0=tree[o].v0=(r-l+1)*(v^1);
    }
    else {
    int mid = (l + r)>>1;
    pushdown(mid, o, l, r);
    if(ql <= mid)update(ql, qr, v, o<<1, l, mid);
    if(qr > mid)update(ql, qr, v, o<<1|1, mid+1, r);
    pushup(mid, o, l, r);
    }
}
void change(int ql, int qr, int o, int l, int r)
{
    if(ql <= l&&r <= qr)
        fxor(o, l, r);
    else 
    {
        int mid = (l + r)>>1;
        pushdown(mid, o, l, r);
        if(ql <= mid)change(ql, qr, o<<1, l, mid);
        if(qr > mid)change(ql, qr, o<<1|1, mid+1, r);
        pushup(mid, o, l, r);
    }
}
int sum(int ql, int qr, int o, int l, int r)
{
    if(ql <= l&&r <= qr)
            return tree[o].sum;
    int mid = (l + r)>>1;
    int ans = 0;
    pushdown(mid, o, l, r);
    if(ql <= mid)ans += sum(ql, qr, o<<1, l, mid);
    if(qr > mid)ans += sum(ql, qr, o<<1|1, mid+1, r);
    return ans;
}
int query(int ql, int qr, int o, int l, int r)
{
    if(ql <= l&& r <= qr)
        return tree[o].v1;
    int temp, ans, mid = (l + r) >>1;
    ans = 0;
    pushdown(mid, o, l, r);
    if(ql <= mid)ans =max (ans, query(ql, qr, o<<1, l, mid));
    if(qr > mid)ans =max (ans, query(ql, qr, o<<1|1, mid+1, r));
    temp=min(qr-mid,tree[o<<1|1].left1) + min(mid-ql+1, tree[o<<1].right1);
    return max(ans, temp);
}
int main()
{
    int T, n, m, a, b;
    int s;
    scanf("%d", &T);
    while (T--)
    {
        scanf("%d %d", &n, &m);
        build(1, 1, n);
        while(m--)
        {
        scanf("%d %d %d", &s, &a, &b);
        a++;b++;
        if(s == 0||s == 1)
            update(a, b, s, 1, 1, n);
        else if(s == 2)    
            change(a, b, 1, 1, n);
        else if(s == 3)
            printf("%d\n", sum(a, b, 1, 1, n));
        else 
            printf("%d\n", query(a, b, 1, 1, n));
        }
    }
    return 0;
}

4.hdu2871 Memory Control

#include <stdio.h>
#include <string.h>
#define maxn 50010
#include <algorithm>
using namespace std;
struct node {
    int left, right, sum;
    int lazy, cover, num;
    int st, end;
}tree[maxn<<2];
int n, q;
void pushup(int mid, int o, int l, int r)
{
    tree[o].left = tree[o<<1].left;
    tree[o].right = tree[o<<1|1].right;
    tree[o].sum = max(tree[o<<1].sum, tree[o<<1|1].sum);
    if(tree[o].left == (mid - l + 1))tree[o].left += tree[o<<1|1].left;
    if(tree[o].right == (r-mid))tree[o].right += tree[o<<1].right;
    tree[o].sum = max(tree[o].sum, tree[o<<1].right + tree[o<<1|1].left);
}
void pushdown(int mid, int o, int l, int r)
{
    if(tree[o].lazy != -1)
    {
        tree[o<<1].lazy = tree[o<<1|1].lazy = tree[o].lazy;
        tree[o<<1].sum=tree[o<<1].left=tree[o<<1].right=(mid-l+1)*tree[o].lazy;
        tree[o<<1|1].sum=tree[o<<1|1].left=tree[o<<1|1].right=(r-mid)*tree[o].lazy;
        tree[o<<1].st = tree[o<<1|1].st = tree[o].st;
        tree[o<<1].end = tree[o<<1|1].end = tree[o].end;
        tree[o].lazy = -1;
    }
}
int New(int x, int o, int l, int r)
{
    if(l == r)return l;
    int mid = (l + r)>>1;
    pushdown(mid, o, l, r);
    if(tree[o<<1].sum >= x)
        return New(x, o<<1, l, mid);
    else if(tree[o<<1|1].left + tree[o<<1].right >= x)
        return mid - tree[o<<1].right + 1; 
    else return New(x, o<<1|1, mid+1, r);
}
void update(int ql, int qr, int v, int o, int l, int r)
{
    if(ql <= l&& r <= qr)
    {
        tree[o].lazy = v;
        tree[o].sum=tree[o].left=tree[o].right=v*(r-l+1);
        if(v)tree[o].st = tree[o].end = -1;
        else {
            tree[o].st = ql;
            tree[o].end = qr;
        }
    }
    else {
    int mid = (l + r) >>1;
    pushdown(mid, o, l, r);
    if(ql <= mid)update(ql, qr, v, o<<1, l, mid);
    if(qr > mid)update(ql, qr, v, o<<1|1, mid+1, r);
    pushup(mid, o, l, r);
    }
}
void countdown(int o)
{
    if(tree[o].cover)
    {
        tree[o<<1].num = tree[o<<1|1].num = 0;
        tree[o<<1].cover = tree[o<<1|1].cover = 1;
        tree[o].cover = 0;
    }
}
void count(int x, int v, int o, int l, int r)
{
    if(l == r)
    {
        tree[o].num = v;
    }
    else {
    countdown(o);
    int mid = (l + r) >>1 ;
    if(x<=mid)count(x, v, o<<1, l, mid);
    else count(x, v, o<<1|1, mid+1, r);
    tree[o].num = tree[o<<1].num + tree[o<<1|1].num;
    }
}
void build(int o, int l, int r)
{
    update(1, n, 1, 1, 1, n);
    tree[1].cover = 1;
    tree[1].num = 0;
}
int free(int x, int o, int l, int r)
{
    if(l == r)
        return o;
    int mid = (l + r) >> 1;
    pushdown(mid, o, l, r);
    if(x <= mid)return free(x, o<<1, l, mid);
    else return free(x, o<<1|1, mid+1, r);
}
int get(int x, int o, int l, int r)
{
    if (l == r)
        return  l;
    else 
    {
        int mid = (l + r) >>1 ;
        countdown(o);
        if(tree[o<<1].num >= x) return get(x, o<<1, l, mid);
        else return get(x-tree[o<<1].num, o<<1|1, mid+1, r);
    }
}
int main()
{
    int x, ans;
    char s[10];
    while (~scanf("%d %d", &n, &q))
{
    build(1, 1, n);
    while (q--)
    {
        scanf("%s", s);
        if(!strcmp(s,"Reset"))
        {
            build(1, 1, n);
            printf("Reset Now\n");
            continue;
        }
        scanf("%d", &x);
         if(!strcmp(s,"New"))
        {
            if (tree[1].sum >= x)
            {
                ans = New(x, 1, 1, n);        
                printf("New at %d\n", ans);
                count(ans, 1, 1, 1, n);
                update(ans, x+ans-1, 0, 1, 1, n);
                continue;
            }
            else 
                printf("Reject New\n");
        }
        else if(!strcmp(s, "Free"))
        {
            ans = free(x, 1, 1, n);
            if(tree[ans].st < 0)printf("Reject Free\n");
            else {
                printf("Free from %d to %d\n", tree[ans].st, tree[ans].end);
                count(tree[ans].st, 0, 1, 1, n);
                update(tree[ans].st, tree[ans].end, 1, 1, 1, n);
            } 
        }
        else {
            if(x > tree[1].num)printf("Reject Get\n");
            else 
             printf("Get at %d\n", get(x, 1, 1, n));
        }
    }
    printf("\n");
}    
}

5.hdu1540 Tunnel Warfare

#include <stdio.h>
#include <stack>
#include <algorithm>
using namespace std;
stack <int> q;
int n, m, x;
struct node{
    int lsum, rsum, sum;
}tree[50010<<2];
char s[10];
void build(int o, int l, int r)
{
    tree[o].sum = tree[o].lsum = tree[o].rsum = r - l + 1;
    if(l == r)return ;
    int mid = (l + r) >> 1;
    build(o<<1, l ,mid);
    build(o<<1|1, mid+1, r);
}
void pushup(int o, int l, int r)
{
    int mid = (l + r) >> 1;
    tree[o].lsum = tree[o<<1].lsum;
    tree[o].rsum = tree[o<<1|1].rsum;
    if(tree[o].lsum == mid-l+1)tree[o].lsum += tree[o<<1|1].lsum;
    if(tree[o].rsum == r-mid)tree[o].rsum += tree[o<<1].rsum;
    tree[o].sum = max(tree[o<<1].sum, tree[o<<1|1].sum);
    tree[o].sum = max(tree[o<<1].rsum+tree[o<<1|1].lsum, tree[o].sum);
}
void update(int x, int v, int o, int l ,int r)
{
    if(l == r)
    {
        tree[o].sum = tree[o].lsum = tree[o].rsum = v;
        return ;
    }
    int mid = (l + r) >> 1;
    if(x <= mid)update(x, v, o<<1, l, mid);
    else update(x, v, o<<1|1, mid+1, r);
    pushup(o, l, r);
}
int query(int x, int o, int l, int r)
{
    if(l == r)
        return tree[o].lsum;
    int mid = (l + r)>>1;
    if(x <= mid)
    {
        if(tree[o<<1].lsum == mid-l+1)
                return tree[o<<1].lsum + tree[o<<1|1].lsum;
        else if(l+tree[o<<1].lsum > x)
                return tree[o<<1].lsum;
        else if(x > mid - tree[o<<1].rsum)
                return tree[o<<1].rsum + tree[o<<1|1].lsum;
        else return query(x, o<<1, l, mid);
    }
    else {
        if(tree[o<<1|1].rsum == r - mid)
                return tree[o<<1].rsum + tree[o<<1|1].rsum;
        else if(mid + tree[o<<1|1].lsum+1 > x)
                return tree[o<<1].rsum + tree[o<<1|1].lsum;
        else if(x > r - tree[o<<1|1].rsum)
                return tree[o<<1|1].rsum;
        else return query(x, o<<1|1, mid+1, r);

    }

}
int main()
{
    while (~scanf("%d %d", &n, &m))
    {
        build(1, 1, n);
        for(;!q.empty();q.pop());
        while (m--)
        {
            scanf("%s", s);
            if (s[0] == 'D')
            {
                scanf("%d", &x);
                update(x, 0, 1, 1, n);
                q.push(x);
            }
            if(s[0] == 'Q')
            {
                scanf("%d", &x);
                printf("%d\n", query(x, 1, 1, n));
            }
            if(s[0] == 'R')
            {
                if(!q.empty())
                {
                int y = q.top();q.pop();
                update(y, 1, 1, 1, n);
                }
            }
        }
    }
}

扫描线暂时搁置