线段树

线段树的基本模版
//建树
void build(int k,int l,int r)
{
	a[k].l=l;
	a[k].r=r;
	if(l==r)
	{
		a[k].num=a[k].sum=cnt[1];
		return ;
	}
	//pushdown(x);更新时下传 
	int mid=(l+r)>>1;
	build(k<<1,l,mid);
	build(k<<1|1,mid+1,r);
	pushup(k);
} 
//单点更新
void update(int k,int pos,int val)
{
	if(a[k].l==a[k].r)
	{
		a[k].num+=val;
		a[k].sum+=val;
		return ;
	} 
	int mid=(a[k].l+a[k].r)>>1;
	if(mid>=pos)
	update(k<<1,pos,val);
	else
	update(k<<1|1,pos,val);
	pushup(k);
} 
//查询区间
int query(int k,int l,int r)
{
	if(a[k].l==l&&a[k].r==r)
	return a[k].sum;
	int mid=(a[k].l+a[k].r)>>1;
	//poshdown(rt)  查询时下传标记 
	if(r<=mid)
	return query(k<<1,l,r);
	else if(l>mid)
	return query(k<<1|1,l,r);
	else return query(k<<1,l,mid)+query(k<<1|1,mid+1,r); 
} 
//查询区间最大值
int query(int rt,int l,int r)
{
	if(s[rt].l==s[rt].r==r)
	return s[rt].maxa;
	else
	{
		int mid=(s[rt].l+s[rt].r)>>1;
		if(r<=mid)
		return query(rt<<1,l,r);
		else if(l>mid)
		return query(rt<<1|1,l,r);
		else return max(query(rt<<1,l,mid),query(rt<<1|1,mid+1,r));
	} 
} 
//下传标记 
void pushdown(int x)
{
	int lazyval=t[x].lazy;
	if(lazyval)
	{
		t[x<<1].sum=(t[x<<1].r-t[x<<1].l+1)*lazybval;
		t[x<<1|1].sum=(t[x<<1|1].r-t[x<<1|1].l+1)*lazyval;
		t[x<<1].lazy=lazyval;
		t[x<<1|1].lazy=lazyval;
		t[x].lazy=0; 
	}
}
void pushup(int k)	//自下而上更新的操作 
{
	a[k].sum=a[k<<1].sum+a[k<<1|1].sum;
}

排兵布阵
/**
 *线段树的简单应用,用scanf和printf输入输出
 *cin和cout会超时
 */
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
int a[50001];//存储结点的位置
struct node{
    int left,right;//线段区间
    int sum;//区间上的人数
}b[150005];
void Build(int left,int right,int i){//建树
    int mid;
    b[i].left=left;
    b[i].right=right;
    if(left==right){//先用数组存下该队的人
        b[i].sum=a[left];
        return ;
    }
    //cout<<"ok"<<endl;
    mid=(left+right)/2;
    Build(left,mid,2*i);//递归建立左子树
    Build(mid+1,right,2*i+1);//递归建立右子树
    b[i].sum=b[2*i].sum+b[2*i+1].sum;//记录该结点左右子树的值
}
 
void Add(int j,int num,int i){
    if(b[i].left==b[i].right){//到达叶子结点
        b[i].sum+=num;
        return ;//注意返回
    }
    else{
        b[i].sum+=num;//他的所有父节点都增加
        if(j<=b[i*2].right) Add(j,num,2*i);//递归左子树
        else Add(j,num,2*i+1);//建立右子树
    }
}
 
int Query(int left,int right,int i){//查询
    int mid;
    if(b[i].left==left&&b[i].right==right) return b[i].sum;
    mid=(b[i].left+b[i].right)/2;
    if(right<=mid) return Query(left,right,2*i);//在左子树
    else if(left>mid) return Query(left,right,2*i+1);//在右子树
    else return Query(left,mid,2*i)+Query(mid+1,right,2*i+1);//否则在中间
}
int main()
{
    int t,k=0,i,j,num,n;
    char s[10];
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        for(i=1;i<=n;i++){
            scanf("%d",&a[i]);
        }
        //cout<<"Case "<<++k<<":"<<endl;
        printf("Case %d:\n",++k);
        Build(1,n,1);//建树
        while(1){
            scanf("%s",s);
            if(!strcmp(s,"End")) break;
            scanf("%d%d",&j,&num);
            if(!strcmp(s,"Query")){
                printf("%d\n",Query(j,num,1));
                //cout<<Query(j,num,1)<<endl;
            }
            if(!strcmp(s,"Add")) Add(j,num,1);//从根结点开始
            if(!strcmp(s,"Sub")) Add(j,-num,1);
 
        }
    }
    return 0;
}

很多学校流行一种比较的习惯。老师们很喜欢询问，从某某到某某当中，分数最高的是多少。
这让很多学生很反感。

不管你喜不喜欢，现在需要你做的是，就是按照老师的要求，写一个程序，模拟老师的询问。当然，老师有时候需要更新某位同学的成绩。
#include <iostream>
#include <cstdio>
#include <cstring>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;
const double eps = 1e-6;
const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int MOD = 1000000007;
#define ll long long
#define CL(a,b) memset(a,b,sizeof(a))
#define MAXN 800010
 
struct node
{
    int a,b,r;
}t[MAXN];
int n,m,ans;
 
void build(int x, int y, int num)
{
    t[num].a = x;
    t[num].b = y;
    t[num].r = 0;
    if(x == y) return ;
    int mid = (x+y)/2;
    build(x, mid, num*2);
    build(mid+1, y, num*2+1);
}
 
void update(int x, int y, int num)
{
    if (t[num].a == t[num].b && t[num].b == x)
    {
        t[num].r = y;
        return ;
    }
    int mid = (t[num].a+t[num].b)/2;
    if(x > mid) update(x, y, num*2+1);
    else update(x, y, num*2);
    t[num].r = max(t[num*2].r, t[num*2+1].r);
}
 
void query(int x, int y, int num)
{
     if(t[num].a == x && t[num].b == y)
     {
         ans = max(ans, t[num].r);
         return ;
     }
     int mid = (t[num].a+t[num].b)/2;
     if(x >= mid+1) query(x, y, num*2+1);
     else if(y <= mid) query(x, y, num*2);
     else
     {
         query(x, mid, num*2);
         query(mid+1, y, num*2+1);
     }
}
 
int main()
{
    char ch;
    int x,y,k;
    while(scanf("%d%d",&n,&m)==2)
    {
        build(1, n, 1);
        for(int i=1; i<=n; i++)
        {
            scanf("%d",&k);
            update(i, k, 1);
        }
 
        while(m--)
        {
            getchar();
            scanf("%c%d%d",&ch,&x,&y);
            if(ch == 'U')
            {
                update(x, y, 1);
            }
            else if(ch == 'Q')
            {
                ans = -99999;
                query(x, y, 1);
                printf("%d\n",ans);
            }
        }
    }
    return 0;
}

有一家公司有N个员工(从1到N)，公司的每个员工都有一个直属上司(除了整个公司的领导)。如果你是某人的直属老板，那个人就是你的下属，他的所有下属也都是你的下属。如果你不是任何人的老板，那么你就没有下属，没有直接上司的员工就是整个公司的领导，所以这意味着N个员工组成了一棵树。

公司通常会将一些任务分配给一些员工完成，当一个任务分配给某人时，他/她会将它分配给他/她的所有下属，也就是说，这个人和他/她的所有下属在同一时间收到一项任务。此外，每当员工收到任务时，他/她将停止当前任务(如果他/她有)并开始新的任务。

写一个程序，在公司将一些任务分配给一些员工之后，它将有助于了解一些员工当前的任务。
#include<bits/stdc++.h>
using namespace std;

const int maxn = 1e6+10;
int a[maxn<<2],tag[maxn<<2];
int n,q,t;
vector<int> G[maxn];
int inout[maxn];
int s[maxn];
int e[maxn];
int nn;
char ch[10];

void dfs(int u){
    s[u] = ++nn;
    for(int i=0;i<G[u].size();i++){
        int v = G[u][i];
        dfs(v);
    }
    e[u] = ++nn;
}

void pushdown(int o,int m){
  if(tag[o]!=-1){
    tag[o<<1] = tag[o];
    tag[o<<1|1] = tag[o];
    tag[o] = -1;
  }
}

void build(int o,int l,int r){
  tag[o] = -1;
  if(l<r){
    int mid = l+r>>1;
    build(o<<1,l,mid);
    build(o<<1|1,mid+1,r);
  }
}

void update(int o,int tl,int tr,int l,int r,int v){
  if(tr<l||r<tl)return;
  if(l<=tl&&tr<=r){
      tag[o] = v;
        return;
  }
  pushdown(o,tr-tl+1);
  int mid = (tl+tr)>>1;
  update(o<<1,tl,mid,l,r,v);
  update(o<<1|1,mid+1,tr,l,r,v);
} 

int query(int o,int tl,int tr,int v){
  if(tl==tr)return tag[o];
  pushdown(o,tr-tl+1);
  int mid = (tl+tr)>>1;
  if(v<=mid)
  return query(o<<1,tl,mid,v);
  else return query(o<<1|1,mid+1,tr,v);
}

int main(){
    scanf("%d",&t);
    int kase = 0;
    while(t--){
        memset(inout,0,sizeof(inout));
        scanf("%d",&n);
        nn = 0;
        for(int i=0;i<=n;i++)G[i].clear();
        printf("Case #%d:\n",++kase);
        for(int i=0;i<n-1;i++){
            int b,c;
            scanf("%d%d",&b,&c);
            G[c].push_back(b);
            inout[b]++;
        }
        for(int i=1;i<=n;i++){
            if(!inout[i])dfs(i);//从根节点开始dfs建立序列
        }
        build(1,1,nn);//根据新序列建立线段树
        scanf("%d",&q);
        for(int i=0;i<q;i++){  
            int p,o;
            scanf("%s%d",ch,&p);
            if(ch[0]=='C')printf("%d\n",query(1,1,nn,e[p]));
            if(ch[0]=='T'){
                scanf("%d",&o);
                update(1,1,nn,s[p],e[p],o);
            }
        }
    }
    return  0;
}