线段树基础板子题

在选拔赛补题时被线段树虐哭，然后一直想学线段树又一直学不下去，这次再来学一学吧！希望线段树别再虐孩子了。
总结：
push_up:针对于题目查询的性质（比如求区间和，区间最小值…）
push_down用于懒惰标记
1.敌兵布阵 HDU - 1166

int t,n,a[50010],tree[50005*4];//tree要开a的4倍
char s[10];
//建树
void build(int node,int l,int r)
{
    if(l==r)
    {
        tree[node]=a[l];
        return;
    }
    int mid=(l+r)/2;
    build(node*2,l,mid);
    build(node*2+1,mid+1,r);
    tree[node]=tree[node*2]+tree[node*2+1];
}
//单点修改
void change(int i,int j,int node,int l,int r)
{
    if(l==r)
    {
        tree[node]+=j;
        return;
    }
    int mid=(l+r)/2;
    if(i>=l&&i<=mid)change(i,j,node*2,l,mid);
    else change(i,j,node*2+1,mid+1,r);
    tree[node]=tree[node*2]+tree[node*2+1];
}
//区间和查询
int query(int i,int j,int node,int l,int r)
{
    if(i<=l&&j>=r)return tree[node];
    if(j<l||i>r)return 0;
    int sum=0;
    int mid=(l+r)/2;
    if(mid>=i)sum+=query(i,j,node*2,l,mid);
    if(mid+1<=j)sum+=query(i,j,node*2+1,mid+1,r);
    return sum;
}
int main()
{
    scanf("%d",&t);
    for(int ii=1;ii<=t;ii++)
    {
        printf("Case %d:\n",ii);
        scanf("%d",&n);
        for(int i=1;i<=n;i++)scanf("%d",&a[i]);
        build(1,1,n);
        //for(int i=1;i<=n*4;i++)printf("%d ",tree[i]);
        for(;;)
        {
            scanf("%s",s);
            if(s[0]=='A')
            {
                int i,j;
                scanf("%d%d",&i,&j);
                change(i,j,1,1,n);
            }
            else if(s[0]=='S')
            {
                int i,j;
                scanf("%d%d",&i,&j);
                change(i,-j,1,1,n);
            }
            else if(s[0]=='Q')
            {
                int i,j;
                scanf("%d%d",&i,&j);
                printf("%d\n",query(i,j,1,1,n));
            }
            else break;
        }
    }
    return 0;
}

2.I Hate It HDU - 1754
单点更新，求区间最大值。
求区间和tree就存和，求最大值就存最大值。
注意：字符输入要开字符串，要不会tle，求大佬解答为什么。

#define ll long long
#define mod 0x3f3f3f3f
#define INF 1e9
using namespace std;
int n,m;
int tree[200010*4];
//tree储存最大值
void pushup(int node){tree[node]=max(tree[node*2],tree[node*2+1]);}
//建树
void build(int node,int l,int r)
{
    if(l==r)
    {
        scanf("%d",&tree[node]);
        return ;
    }
    int mid=(l+r)/2;
    build(node*2,l,mid);
    build(node*2+1,mid+1,r);
    pushup(node);
}
//单点更新
void update(int a,int b,int node,int l,int r)
{
    if(l==r)
    {
        tree[node]=b;
        return;
    }
    int mid=(l+r)/2;
    if(a>=l&&a<=mid)update(a,b,node*2,l,mid);
    else update(a,b,node*2+1,mid+1,r);
    pushup(node);
}
//区间最大值查询
int query(int a,int b,int node,int l,int r)
{
    if(l>=a&&r<=b)return tree[node];
    int mid=(l+r)/2;
    int ans=-INF;
    if(mid>=a)ans=max(ans,query(a,b,node*2,l,mid));
    if(mid+1<=b)ans=max(ans,query(a,b,node*2+1,mid+1,r));
    return ans;

}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        build(1,1,n);
        while(m--)
        {
            char c[5];int a,b;
            scanf("%s%d%d",&c,&a,&b);
            if(c[0]=='U')
            {
                update(a,b,1,1,n);
            }
            else if(c[0]=='Q')
            {
                printf("%d\n",query(a,b,1,1,n));
            }
        }
    }
    return 0;
}

3.A Simple Problem with Integers POJ - 3468
区间修改，区间查询；

int n,q;
ll tree[100010*4],add[100010*4];//add懒惰标记
void push_up(int node){tree[node]=tree[node*2]+tree[node*2+1];}
void build(int node,int l,int r)
{
    if(l==r)
    {
        scanf("%lld",&tree[node]);
        return ;
    }
    int mid=(l+r)/2;
    build(node*2,l,mid);
    build(node*2+1,mid+1,r);
    push_up(node);
}
void push_down(int node,int l,int r)
{
    if(add[node])
    {
        int mid=(l+r)/2;
        tree[node*2]+=(mid-l+1)*add[node];
        add[node*2]+=add[node];
        tree[node*2+1]+=(r-(mid+1)+1)*add[node];
        add[node*2+1]+=add[node];
        add[node]=0;
    }
}
//区间修改
void modify(int a,int b,int c,int node,int l,int r)
{
    if(a<=l&&b>=r)
    {
        tree[node]+=(r-l+1)*c;
        add[node]+=c;
    }
    else
    {
        push_down(node,l,r);
        int mid=(l+r)/2;
        if(a<=mid)modify(a,b,c,node*2,l,mid);
        if(b>=mid+1)modify(a,b,c,node*2+1,mid+1,r);
        push_up(node);
    }
}
//区间查询
ll query(int a,int b,int node,int l,int r)
{
    if(a<=l&&b>=r)return tree[node];
    push_down(node,l,r);
    int mid=(l+r)/2;
    ll s=0;
    if(mid>=a)s+=query(a,b,node*2,l,mid);
    if(mid+1<=b)s+=query(a,b,node*2+1,mid+1,r);
    return s;
}
int main()
{
    scanf("%d%d",&n,&q);
    build(1,1,n);
    while(q--)
    {
        char s[5];scanf("%s",s);
        if(s[0]=='Q')
        {
            int a,b;
            scanf("%d%d",&a,&b);
            printf("%lld\n",query(a,b,1,1,n));
        }
        if(s[0]=='C')
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            modify(a,b,c,1,1,n);
        }
    }
    return 0;
}

4.Mayor’s posters POJ - 2528

lower_bound( )和upper_bound( )都是利用二分查找的方法在一个排好序的数组中进行查找的。

在从小到大的排序数组中，

lower_bound( begin,end,num)：从数组的begin位置到end-1位置二分查找第一个大于或等于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。

upper_bound( begin,end,num)：从数组的begin位置到end-1位置二分查找第一个大于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。

在从大到小的排序数组中，重载lower_bound()和upper_bound()

lower_bound( begin,end,num,greater() ):从数组的begin位置到end-1位置二分查找第一个小于或等于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。

upper_bound( begin,end,num,greater() ):从数组的begin位置到end-1位置二分查找第一个小于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。

线段树（单点查询，区间更新）+离散化。
离散化（个人理解）：把原区间映射到新的区间，不改变原有性质，以此缩短区间。此题原染色区间过大，然后发现n张海报，有n*2个点，把此作为建树基础。
ps:确实感觉这道题和题意其实有出入，题意里若1-10被1-3和7-10覆盖，应该有三种颜色，但这里只考虑了两钟，没有3-7。题意里考虑的是区间，但代码写出来实际是点的覆盖，这里有4个点：1，3，7，10；1，3；7，10；后来皆被覆盖，所以就只有了两种颜色。

int t,n;
int vis[10010*4],add[10010*8];
struct node
{
    int a,b;
}w[10010*2];
int v[10010*4];
void pushdown(int node)
{
    if(add[node])
    {
        add[node*2]=add[node];
        add[node*2+1]=add[node];
        add[node]=0;
    }
}
void update(int node,int l,int r,int a,int b,int i)
{
    if(a<=l&&b>=r)
    {
        add[node]=i;
        return;
    }
    pushdown(node);
    int mid=(l+r)/2;
    if(a<=mid)update(node*2,l,mid,a,b,i);
    if(b>=mid+1)update(node*2+1,mid+1,r,a,b,i);

}
int query(int node,int l,int r,int i)
{
    if(l==r)return add[node];
    pushdown(node);
    int mid=(l+r)/2;
    if(i<=mid)query(node*2,l,mid,i);
    else query(node*2+1,mid+1,r,i);
}
int main()
{
    scanf("%d",&t);
    while(t--)
    {
        memset(vis,0,sizeof(vis));
        //和基础的不太一样，这里只用一个数组，由于初始为0，所以不用写建树。
        memset(add,0,sizeof(add));
        scanf("%d",&n);
        int cnt=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%d%d",&w[i].a,&w[i].b);
            v[++cnt]=w[i].a;
            v[++cnt]=w[i].b;
        }
        sort(v+1,v+1+cnt);
        cnt=unique(v+1,v+1+cnt)-v-1;
        for(int i=1;i<=n;i++)
        {
            int l=lower_bound(v+1,v+1+cnt,w[i].a)-v;
            //在v中找第一个>=w[i].a的数，返回其地址。
            int r=lower_bound(v+1,v+1+cnt,w[i].b)-v;
            update(1,1,2*n,l,r,i);
        }
        for(int i=1;i<=n*2;i++)
        {
            int tmp=query(1,1,2*n,i);
            vis[tmp]=1;
        }
        int sum=0;
        for(int i=1;i<=2*n;i++)sum+=vis[i];
        printf("%d\n",sum);
    }
    return 0;
}

5.Just a Hook HDU - 1698
区间修改；

int t,n,q;
int tree[100010*4],add[100010*4];
void pushup(int node){tree[node]=tree[node*2]+tree[node*2+1];}
void build(int node,int l,int r)
{
    if(l==r)
    {
        tree[node]=1;
        return;
    }
    int mid=(l+r)/2;
    build(node*2,l,mid);
    build(node*2+1,mid+1,r);
    pushup(node);
}
void pushdown(int node,int l,int r)
{
    if(add[node])
    {
        int mid=(l+r)/2;
        add[node*2]=add[node];
        add[node*2+1]=add[node];
        tree[node*2]=(mid-l+1)*add[node];
        tree[node*2+1]=(r-(mid+1)+1)*add[node];
        add[node]=0;
    }
}
void modify(int a,int b,int c,int node,int l,int r)
{
    if(a<=l&&b>=r)
    {
        add[node]=c;
        tree[node]=(r-l+1)*c;
        return;
    }
    pushdown(node,l,r);
    int mid=(l+r)/2;
    if(a<=mid)modify(a,b,c,node*2,l,mid);
    if(b>=mid+1)modify(a,b,c,node*2+1,mid+1,r);
    pushup(node);
}

int main()
{
    scanf("%d",&t);
    for(int i=1;i<=t;i++)
    {
        memset(add,0,sizeof(add));
        scanf("%d",&n);
        build(1,1,n);
        scanf("%d",&q);
        while(q--)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            modify(a,b,c,1,1,n);
        }
        printf("Case %d: The total value of the hook is %d.\n",i,tree[1]);
    }
    return 0;
}

6.Count the Colors ZOJ - 1610
区间覆盖
学会灵活运用query

int add[8010*4],num[8010];
int n,pc;
void pushdown(int node)
{
    if(add[node]!=-1)
    {
        add[node*2]=add[node];
        add[node*2+1]=add[node];
        add[node]=-1;
    }
}
void modify(int a,int b,int c,int node,int l,int r)
{
    if(a<=l&&b>=r)
    {
        add[node]=c;
        return;
    }
    pushdown(node);
    int mid=(l+r)/2;
    if(a<=mid)modify(a,b,c,node*2,l,mid);
    if(b>=mid+1)modify(a,b,c,node*2+1,mid+1,r);
}
void query(int node,int l,int r)
{
    if(l==r)
    {
        if(add[node]!=-1&&add[node]!=pc)
            num[add[node]]++;
        pc=add[node];
        return;
    }
    pushdown(node);
    int mid=(l+r)/2;
    query(node*2,l,mid);
    query(node*2+1,mid+1,r);
}
int main()
{
    while(~scanf("%d",&n))
    {
        pc=-1;
        memset(add,-1,sizeof(add));
        memset(num,0,sizeof(num));
        for(int i=1;i<=n;i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            modify(a+1,b,c,1,1,8000);
            //其实有一点点疑惑
            //为什么要从+1开始
            //看一些大佬的解释是区间覆盖这样搞

        }
        query(1,1,8000);
        for(int i=0;i<=8000;i++)//不能为n
        {
            if(num[i])printf("%d %d\n",i,num[i]);
        }
        printf("\n");
    }
    return 0;
}

7.Balanced Lineup POJ - 3264
建两棵树一棵存最大值一棵存最小值

int tree1[50010*4],tree2[50010*4],a[50010];
int n,q;
void build(int node,int l,int r)
{
    if(l==r)
    {
        tree1[node]=tree2[node]=a[l];
        return;
    }
    int mid=(l+r)/2;
    build(node*2,l,mid);
    build(node*2+1,mid+1,r);
    tree1[node]=max(tree1[node*2],tree1[node*2+1]);
    tree2[node]=min(tree2[node*2],tree2[node*2+1]);
}
int query1(int a,int b,int node,int l,int r)
{
    if(a<=l&&b>=r)return tree1[node];
    int mid=(l+r)/2;
    int ans=0;
    if(a<=mid)ans=max(ans,query1(a,b,node*2,l,mid));
    if(b>=mid+1)ans=max(ans,query1(a,b,node*2+1,mid+1,r));
    return ans;
}
int query2(int a,int b,int node,int l,int r)
{
    if(a<=l&&b>=r)return tree2[node];
    int mid=(l+r)/2;
    int ans=INF;
    if(a<=mid)ans=min(ans,query2(a,b,node*2,l,mid));
    if(b>=mid+1)ans=min(ans,query2(a,b,node*2+1,mid+1,r));
    return ans;
}
int main()
{
    scanf("%d%d",&n,&q);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    build(1,1,n);
    while(q--)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        printf("%d\n",query1(a,b,1,1,n)-query2(a,b,1,1,n));
    }
    return 0;
}

8.Can you answer these queries? HDU - 4027
呃呃呃 总感觉2的63次方爆longlong了
特殊的区间更新转化为单点更新，因为全为1时，开方不变。

int n,q;
ll tree[100010*4];
void build(int node,int l,int r)
{
    if(l==r)
    {
        scanf("%lld",&tree[node]);
        return ;
    }
    int mid=(l+r)/2;
    build(node*2,l,mid);
    build(node*2+1,mid+1,r);
    tree[node]=tree[node*2]+tree[node*2+1];
}
void update(int a,int b,int node,int l,int r)
{
    if(tree[node]==r-l+1)return;
    if(l==r)
    {
        tree[node]=(ll)sqrt(tree[node]);
        return;
    }
    int mid=(l+r)/2;
    if(a<=mid)update(a,b,node*2,l,mid);
    if(b>=mid+1)update(a,b,node*2+1,mid+1,r);
    tree[node]=tree[node*2]+tree[node*2+1];
}
ll query(int a,int b,int node ,int l,int r)
{
    if(a<=l&&b>=r)return tree[node];
    int mid=(l+r)/2;
    ll s=0;
    if(a<=mid)s+=query(a,b,node*2,l,mid);
    if(b>=mid+1)s+=query(a,b,node*2+1,mid+1,r);
    return s;
}
int main()
{
    int cnt=0;
    while(~scanf("%d",&n))
    {
        build(1,1,n);
        scanf("%d",&q);
        printf("Case #%d:\n",++cnt);
        while(q--)
        {
            int t,x,y;
            scanf("%d%d%d",&t,&x,&y);
            if(x>y)swap(x,y);
            if(t==0)
            {
                update(x,y,1,1,n);
            }
            if(t==1)
            {
                printf("%lld\n",query(x,y,1,1,n));
            }
        }
        printf("\n");
    }
    return 0;
}

9.Tunnel Warfare HDU - 1540
思路：储存左边的最大值，右边的最小值。
写完之后 觉得很简单，但真的改了好久。

int n,m;
struct node
{
    int mi,ma;
}tree[50010*4];
void build(int node,int l,int r)
{
    if(l==r)
    {
        tree[node].mi=n+1;
        tree[node].ma=0;
        return ;
    }
    int mid=(l+r)/2;
    build(node*2,l,mid);
    build(node*2+1,mid+1,r);
    tree[node].ma=max(tree[node*2].ma,tree[node*2+1].ma);
    tree[node].mi=min(tree[node*2].mi,tree[node*2+1].mi);
}
void update(int x,int node,int l,int r)
{
    if(l==r)
    {
        tree[node].mi=tree[node].ma=x;
        return ;
    }
    int mid=(l+r)/2;
    if(x<=mid)update(x,node*2,l,mid);
    else update(x,node*2+1,mid+1,r);
    tree[node].mi=min(tree[node*2].mi,tree[node*2+1].mi);
    tree[node].ma=max(tree[node*2].ma,tree[node*2+1].ma);
}
void change(int x,int node,int l,int r)
{
    if(l==r)
    {
        tree[node].mi=n+1;
        tree[node].ma=0;
        return ;
    }
    int mid=(l+r)/2;
    if(x<=mid)change(x,node*2,l,mid);
    else change(x,node*2+1,mid+1,r);
    tree[node].mi=min(tree[node*2].mi,tree[node*2+1].mi);
    tree[node].ma=max(tree[node*2].ma,tree[node*2+1].ma);
}
int query1(int a,int b,int node,int l,int r)
{
    if(a<=l&&b>=r)return tree[node].mi;
    int minn=INF;
    int mid=(l+r)/2;
    if(mid>=a)minn=min(minn,query1(a,b,node*2,l,mid));
    if(b>=mid+1)minn=min(minn,query1(a,b,node*2+1,mid+1,r));
    return minn;
}
int query2(int a,int b,int node,int l,int r)
{
    if(a<=l&&b>=r)return tree[node].ma;
    int maxn=0;
    int mid=(l+r)/2;
    if(mid>=a)maxn=max(maxn,query2(a,b,node*2,l,mid));
    if(b>=mid+1)maxn=max(maxn,query2(a,b,node*2+1,mid+1,r));
    return maxn;
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        stack<int>sta;
        build(1,1,n);
        while(m--)
        {
            char s[5];int x;
            scanf("%s",s);
            if(s[0]=='D')
            {
                scanf("%d",&x);
                update(x,1,1,n);
                sta.push(x);
            }
            if(s[0]=='Q')
            {
                scanf("%d",&x);
                int ans=query1(x,n,1,1,n)-query2(1,x,1,1,n);
                if(ans)ans--;
                printf("%d\n",ans);
            }
            if(s[0]=='R')
            {
                if(!sta.empty())change(sta.top(),1,1,n);
                sta.pop();
            }
        }
    }
    return 0;
}

10.Assign the task HDU - 3974
dfs序建树+线段树区间修改 单点查询

const int N=50010;
int t,n,m;
vector<int>a[N];
int lazy[N*4],len[N],num[N],tree[N*4],vis[N];
int dfs(int u)
{
    tree[u]=++m;
    int res=1;
    for(int i=0;i<a[u].size();i++)
    {
        int v=a[u][i];
        if(vis[v])continue;
        vis[v]=1;
        res+=dfs(v);
    }
    return len[u]=res;
}
void pushdown(int node)
{
    if(lazy[node]!=-1)
    {
        lazy[node*2]=lazy[node*2+1]=lazy[node];
        lazy[node]=-1;
    }
}
void update(int a,int b,int c,int node,int l,int r)
{
    if(a<=l&&b>=r)
    {
        lazy[node]=c;
        return;
    }
    pushdown(node);
    int mid=(l+r)/2;
    if(a<=mid)update(a,b,c,node*2,l,mid);
    if(b>=mid+1)update(a,b,c,node*2+1,mid+1,r);
}
int query(int a,int node,int l,int r)
{
    if(l==r)return lazy[node];
    pushdown(node);
    int mid=(l+r)/2;
    if(a<=mid)return query(a,node*2,l,mid);
    else return query(a,node*2+1,mid+1,r);
}
int main()
{
    scanf("%d",&t);
    for(int vv=1;vv<=t;vv++)
    {
        scanf("%d",&n);
        memset(len,0,sizeof(len));
        memset(num,0,sizeof(num));
        for(int i=1;i<=n;i++)a[i].clear();
        for(int i=1;i<n;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            a[v].push_back(u);
            num[u]++;
        }
        for(int i=1;i<=n;i++)
        {
            if(!num[i])
            {
                m=0;
                memset(vis,0,sizeof(vis));
                dfs(i);
                break;
            }
        }
        memset(lazy,-1,sizeof(lazy));
        scanf("%d",&m);
        char s[5];
        printf("Case #%d:\n",vv);
        while(m--)
        {
            scanf("%s",s);
            if(s[0]=='C')
            {
                int x;
                scanf("%d",&x);
                printf("%d\n",query(tree[x],1,1,n));
            }
            else if(s[0]=='T')
            {
                int x,y;
                scanf("%d%d",&x,&y);
                update(tree[x],tree[x]+len[x]-1,y,1,1,n);
            }
        }
    }
    return 0;
}

11.Transformation HDU - 4578
先口胡一下自己刚开始读完题的想法，就是加4个标记，然后就是基本的区间更新和区间求和，然后发现这样还要考虑标记的优先级太难了，然后去看大佬们的思路，有和我一样的。
代码思路：加标记符标记当前区间所有数是否一样，然后区间问题就转化成了单点问题会简单很多。但是也有大佬说这样能过是因为数据水。但我觉得这是一个很好的思路，毕竟四个懒惰标记真的太死亡了。

int mod=10007;
int n,m;
int tree[100010*4],vis[100010*4];
void pushup(int node)
{
    if(!vis[node*2]||!vis[node*2+1])vis[node]=0;
    else if(tree[node*2]!=tree[node*2+1])vis[node]=0;
    else vis[node]=1,tree[node]=tree[node*2];
}
void pushdown(int node)
{
    if(vis[node])
    {
        vis[node*2]=vis[node*2+1]=1;
        tree[node*2]=tree[node*2+1]=tree[node];
        vis[node]=0;
    }
}
void update(int ch,int a,int b,int p,int node,int l,int r)
{
    if(a<=l&&b>=r&&vis[node])
    {
        if(ch==1)
        {
            tree[node]=(tree[node]%mod+p%mod)%mod;
        }
        if(ch==2)
        {
            tree[node]=((tree[node]%mod)*(p%mod))%mod;
        }
        if(ch==3)
        {
            tree[node]=p%mod;
        }
        return ;
    }
    pushdown(node);
    int mid=(l+r)/2;
    if(a<=mid)update(ch,a,b,p,node*2,l,mid);
    if(b>=mid+1)update(ch,a,b,p,node*2+1,mid+1,r);
    pushup(node);
}
int query(int a,int b,int p,int node,int l,int r)
{
    if(a<=l&&b>=r&&vis[node])
    {
        int sum=1;
        for(int i=1;i<=p;i++)sum=((sum%mod)*(tree[node]%mod))%mod;
        sum=((sum%mod)*((r-l+1)%mod))%mod;
        return sum;
    }
    pushdown(node);
    int mid=(l+r)/2;
    int sum=0;
    if(a<=mid)sum=((sum%mod)+(query(a,b,p,node*2,l,mid)%mod))%mod;
    if(b>=mid+1)sum=((sum%mod)+(query(a,b,p,node*2+1,mid+1,r)%mod))%mod;
    return sum;
}
int main()
{
    while(~scanf("%d%d",&n,&m)&&(m||n))
    {
        memset(tree,0,sizeof(tree));
    memset(vis,1,sizeof(vis));
    while(m--)
    {
        int ch,x,y,p;
        scanf("%d%d%d%d",&ch,&x,&y,&p);
        if(ch==4)
        {
            printf("%d\n",query(x,y,p,1,1,n));
        }
        else
        {
            update(ch,x,y,p,1,1,n);
        }
    }
    }
    return 0;
}

12.Vases and Flowers HDU - 4614
思路:tree储存当前有几个空花瓶，lazy初始为-1，插花标记为0，置空标记为1。
操作1:从a花瓶起插入b朵花（瓶子为空才c插），输出第一朵花和最后一朵花的位置。二分查找。
操作2：区间修改。
注意：题目中下标从0到n-1

int t,n,m;
int tree[50010*4],lazy[50010*4];
void pushup(int node){tree[node]=tree[node*2]+tree[node*2+1];}
void build(int node,int l,int r)
{
    if(l==r)
    {
        tree[node]=1;
        return ;
    }
    int mid=(l+r)/2;
    build(node*2,l,mid);
    build(node*2+1,mid+1,r);
    pushup(node);
}
void pushdown(int node,int l,int r)
{
    if(lazy[node]!=-1)
    {
        lazy[node*2]=lazy[node*2+1]=lazy[node];
        int mid=(l+r)/2;
        tree[node*2]=(mid-l+1)*lazy[node];
        tree[node*2+1]=(r-(mid+1)+1)*lazy[node];
        lazy[node]=-1;
    }
}
int query(int a,int b,int node,int l,int r)
{
    if(a<=l&&b>=r)return tree[node];
    pushdown(node,l,r);
    int mid=(l+r)/2;
    int ans=0;
    if(a<=mid)ans+=query(a,b,node*2,l,mid);//
    if(b>=mid+1)ans+=query(a,b,node*2+1,mid+1,r);
    return ans;
}
void update(int a,int b,int c,int node ,int l,int r)
{
    if(a<=l&&b>=r)
    {
        tree[node]=(r-l+1)*c;
        lazy[node]=c;
        return ;
    }
    if(l==r)return;
    pushdown(node,l,r);
    int mid=(l+r)/2;
    if(a<=mid)update(a,b,c,node*2,l,mid);
    if(b>=mid+1)update(a,b,c,node*2+1,mid+1,r);
    pushup(node);
}
//二分查找
int erfind(int x,int num)
{
    int l=x,r=n;
    int ans=0;
    while(l<=r)
    {
        int mid=(l+r)/2;
        //printf("query(l,mid,1,1,n)==%d\n",query(l,mid,1,1,n));
        //注意是查询x到mid，刚开始这里错啦，改了好久。
        if(query(x,mid,1,1,n)>=num)ans=mid,r=mid-1;
        else l=mid+1;
        //printf("ans=%d \n ",ans);
    }
    return ans;
}
int main()
{
    scanf("%d",&t);
    while(t--)
    {
        memset(lazy,-1,sizeof(lazy));//1为空;
        scanf("%d%d",&n,&m);
        build(1,1,n);
        while(m--)
        {
            int ch,a,b;
            scanf("%d%d%d",&ch,&a,&b);
            if(ch==1)
            {
                a++;
                int cnt=query(a,n,1,1,n);
                //printf("cnt=%d  ",cnt);
                if(cnt==0)printf("Can not put any one.\n");
                else
                {
                    int minn=min(b,cnt);
                    //printf("minn=%d \n",minn);
                    int l=erfind(a,1);
                    //printf("l=%d  \n",l);
                    int r=erfind(a,minn);
                    //printf("r=%d  \n",r);
                    printf("%d %d\n",l-1,r-1);
                    update(l,r,0,1,1,n);
                }
            }
            else if(ch==2)
            {
                a++;b++;
                int cnt=query(a,b,1,1,n);
                cnt=(b-a+1)-cnt;
                printf("%d\n",cnt);
                update(a,b,1,1,1,n);
            }
        }
        printf("\n");
    }
    return 0;
}

13.约会安排 HDU - 4553
先吐槽一下这哪里是屌丝码农，明明就是海王呀。
思路：构建两棵树，一棵树储存对屌丝的空闲时间，另一棵树储存对女神的空闲时间，女神的优先级较高，也就是说更新女神时间时也要更新屌丝时间，更新屌丝时间，女神时间不变。如果是要学习，那就所在时间段全部更新为空闲。

const int N=(1e5+10)*4;
int t,n,m;
int vl[N],vr[N],vm[N];
int dl[N],dr[N],dm[N];
void build(int node,int l,int r)
{
    vl[node]=vr[node]=vm[node]=r-l+1;
    dl[node]=dr[node]=dm[node]=r-l+1;
    if(l==r)return;
    int mid=(l+r)/2;
    build(node*2,l,mid);
    build(node*2+1,mid+1,r);
}
void pushup(int node,int l,int r)
{
    int mid=(l+r)/2;
    if(vm[node]==r-l+1)
    {
        vl[node*2]=vr[node*2]=vm[node*2]=mid-l+1;
        vl[node*2+1]=vr[node*2+1]=vm[node*2+1]=r-mid;
    }
    if(vm[node]==0)
    {
        vl[node*2]=vr[node*2]=vm[node*2]=0;
        vl[node*2+1]=vr[node*2+1]=vm[node*2+1]=0;
    }
    if(dm[node]==r-l+1)
    {
        dl[node*2]=dr[node*2]=dm[node*2]=mid-l+1;
        dl[node*2+1]=dr[node*2+1]=dm[node*2+1]=r-mid;
    }
    if(dm[node]==0)
    {
        dl[node*2]=dr[node*2]=dm[node*2]=0;
        dl[node*2+1]=dr[node*2+1]=dm[node*2+1]=0;
    }
}
void pushdown(int node,int l,int r)
{
    int  mid=(l+r)/2;
    vl[node]=vl[node*2];
    vr[node]=vr[node*2+1];
    dl[node]=dl[node*2];
    dr[node]=dr[node*2+1];
    vm[node]=max(max(vm[node*2],vm[node*2+1]),vr[node*2]+vl[node*2+1]);
    dm[node]=max(max(dm[node*2],dm[node*2+1]),dr[node*2]+dl[node*2+1]);
    if(vl[node*2]==mid-l+1)vl[node]+=vl[node*2+1];
    if(vr[node*2+1]==r-mid)vr[node]+=vr[node*2];
    if(dl[node*2]==mid-l+1)dl[node]+=dl[node*2+1];
    if(dr[node*2+1]==r-mid)dr[node]+=dr[node*2];
}
void update(int flag,int a,int b,int c,int node,int l,int r)
{
    if(a<=l&&b>=r)
    {
        if(flag)
        {
            vm[node]=vl[node]=vr[node]=(r-l+1)*c;
            dm[node]=dl[node]=dr[node]=(r-l+1)*c;
        }
        else
        {
            dm[node]=dl[node]=dr[node]=(r-l+1)*c;
        }
        return;
    }
    pushup(node,l,r);
    int mid=(l+r)/2;
    if(a<=mid)update(flag,a,b,c,node*2,l,mid);
    if(b>=mid+1)update(flag,a,b,c,node*2+1,mid+1,r);
    pushdown(node,l,r);
}
int query(int x,int flag,int node,int l,int r)
{
    if(l==r)return 1;
    int mid=(l+r)/2;
    pushup(node,l,r);
    if(flag)
    {
        if(vm[node*2]>=x)
            return query(x,flag,node*2,l,mid);
        else if(vl[node*2+1]+vr[node*2]>=x)
            return mid-vr[node*2]+1;
        else
            return query(x,flag,node*2+1,mid+1,r);
    }
    else
    {
        if(dm[node*2]>=x)
            return query(x,flag,node*2,l,mid);
        else if(dl[node*2+1]+dr[node*2]>=x)
            return mid-dr[node*2]+1;
        else
            return query(x,flag,node*2+1,mid+1,r);
    }
}
int main()
{
    scanf("%d",&t);
    for(int vv=1;vv<=t;vv++)
    {
        scanf("%d%d",&n,&m);
        build(1,1,n);
        printf("Case %d:\n",vv);
        char s[20];
        while(m--)
        {
            scanf("%s",s);
            if(s[0]=='N')
            {
                int x;scanf("%d",&x);
                if(dm[1]>=x)
                {
                    int y=query(x,0,1,1,n);
                    printf("%d,don't put my gezi\n",y);
                    update(1,y,y+x-1,0,1,1,n);
                }
                else if(vm[1]>=x)
                {
                    int y=query(x,1,1,1,n);
                    printf("%d,don't put my gezi\n",y);
                    update(1,y,y+x-1,0,1,1,n);
                }
                else
                {
                    printf("wait for me\n");
                }
            }
            else if(s[0]=='D')
            {
                int x;scanf("%d",&x);
                if(dm[1]>=x)
                {
                    int y=query(x,0,1,1,n);
                    printf("%d,let's fly\n",y);
                    update(0,y,y+x-1,0,1,1,n);
                }
                else
                {
                    printf("fly with yourself\n");
                }
            }
            else
            {
                int x,y;scanf("%d%d",&x,&y);
                update(1,x,y,1,1,1,n);
                printf("I am the hope of chinese chengxuyuan!!\n");
            }
        }
    }
    return 0;
}

14Picture POJ - 1177
扫描线+线段树（具体参照文章扫描线）

const int N=1e4+10;
//cover 统计出入边，入+1，出-1；
//len 记录区间长度
//num 记录线段数量
struct node
{
    int l,r;
    int cover,len,num;
    bool lf,rf;
}tree[N*8];
int y[N];
struct L
{
    int x,y1,y2,id;//id为1为入边,id为-1为出边
}line[N];
bool cmp(L a,L b)
{
    if(a.x==b.x)return a.id>b.id;
    else return a.x<b.x;
}
void pushup(int node)
{
    if(tree[node].cover)
    {
        tree[node].len=y[tree[node].r]-y[tree[node].l];
        tree[node].num=1;
        tree[node].lf=tree[node].rf=true;
    }
    else if(tree[node].l+1==tree[node].r)
    {
        tree[node].lf=tree[node].rf=false;
        tree[node].num=tree[node].len=0;
    }
    else
    {
        tree[node].lf=tree[node*2].lf;
        tree[node].rf=tree[node*2+1].rf;
        tree[node].len=tree[node*2].len+tree[node*2+1].len;
        tree[node].num=tree[node*2].num+tree[node*2+1].num;
        if(tree[node*2].rf&&tree[node*2+1].lf)tree[node].num--;
    }
}
void build(int node,int l,int r)
{
    tree[node].l=l;tree[node].r=r;
    tree[node].num=0;
    if(l+1>=r)return;
    int mid=(l+r)/2;
    build(node*2,l,mid);
    build(node*2+1,mid,r);
}
void update(int node,int a,int b,int ff)
{
    if(a<=y[tree[node].l]&&b>=y[tree[node].r])
    {
        tree[node].cover+=ff;
        pushup(node);
        return;
    }
    if(a<y[tree[node*2].r])update(node*2,a,b,ff);
    if(b>y[tree[node*2+1].l])update(node*2+1,a,b,ff);
    pushup(node);
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        int x1,y1,x2,y2;
        scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
        y[i]=y1;y[i+n]=y2;
        line[i].y1=y1;line[i].y2=y2;
        line[i].x=x1;line[i].id=1;
        line[i+n].y1=y1;line[i+n].y2=y2;
        line[i+n].x=x2;line[i+n].id=-1;
    }
    sort(y+1,y+1+2*n);
    sort(line+1,line+1+2*n,cmp);
    int m=unique(y+1,y+1+2*n)-(y+1);
    build(1,1,m);
    int ans=0,lines=0,last=0;
    for(int i=1;i<=2*n;i++)
    {
        update(1,line[i].y1,line[i].y2,line[i].id);
        ans+=2*lines*(line[i].x-line[i-1].x);
        ans+=abs(last-tree[1].len);
        last=tree[1].len;
        lines=tree[1].num;
    }
    printf("%d\n",ans);
    return 0;
}

15.覆盖的面积 HDU - 1255