[Usaco2009 Feb]庙会捷运Fair Shuttle

Description
公交车一共经过$N(1<=N<=20000)$个站点，从站点1一直驶到站点$N$。$K(1<=K<=50000)$群奶牛希望搭乘这辆公交车。第$i$群牛一共有$M_i(1<=M_i<=N)$只。他们希望从$S_i$到$E_i$去。公交车只能座$C(1<=C<=100)$只奶牛。而且不走重复路线，请计算这辆车最多能满足多少奶牛的要求。
注意：对于每一群奶牛，可以部分满足，也可以全部满足，也可以全部不满足。

Input
第1行： 三个整数： $K$，$N$，$C$。 由空格隔开。
第2..$K+1$行：第$i+1$行，告诉你第i组奶牛的信息： $S_i$, $E_i$and $M_i$。由空格隔开。

Output
一行：可以在庙会乘坐捷运的牛的最大头数

Sample Input
8 15 3
1 5 2
13 14 1
5 8 3
8 14 2
14 15 1
9 12 1
12 15 2
4 6 1

Sample Output
10

HINT
捷运可以把2头奶牛从展台1送到展台5，3头奶牛从展台5到展台8， 2头奶牛从展台8 到展台14，1头奶牛从展台9送到展台12，一头奶牛从展台13送到展台14， 一头奶牛从 14送到15。

Source
Gold

思路
这道题其实很简单，先按照旅行结束地点从小到大排序，如果结束地点相同则按照开始地点从大到小排序，再用线段树维护区间最小值，询问每一批旅客能不能上车，就是询问当前区间的最小值是多少，如果上车$x$头牛就将对应区间减去$x$，答案加上 x <script type="math/tex" id="MathJax-Element-1782">x</script>，最后输出答案即可。

代码

#include <cstdio>
#include <algorithm>

const int maxn=50000;
const int maxm=20000;
const int inf=2000000000;

int n,m,k,ans;

struct data//记录每次旅行的信息
{
    int l,r,lim;

    bool operator <(const data &other) const
    {
        return (r!=other.r)?r<other.r:l>other.l;
    }
};
struct tree//线段树
{
    int val[(maxn<<2)+10],lazy[(maxn<<2)+10];

    int updata(int now)
    {
        return val[now]=std::min(val[now<<1],val[now<<1|1]);
    }

    int pushdown(int now)
    {
        lazy[now<<1]+=lazy[now];
        val[now<<1]+=lazy[now];
        lazy[now<<1|1]+=lazy[now];
        val[now<<1|1]+=lazy[now];
        lazy[now]=0;
        return 0;
    }

    int build(int now,int left,int right)
    {
        if(left==right)
        {
            val[now]=k;
            return 0;
        }
        int mid=(left+right)>>1;
        build(now<<1,left,mid);
        build(now<<1|1,mid+1,right);
        updata(now);
        return 0;
    }

    int ask(int now,int left,int right,int askl,int askr)
    {
        pushdown(now);
        if((left>askr)||(right<askl))
        {
            return inf;
        }
        if((left>=askl)&&(right<=askr))
        {
            return val[now];
        }
        int mid=(left+right)>>1;
        return std::min(ask(now<<1,left,mid,askl,askr),ask(now<<1|1,mid+1,right,askl,askr));
    }

    int change(int now,int left,int right,int askl,int askr,int addval)
    {
        pushdown(now);
        if((left>askr)||(right<askl))
        {
            return 0;
        }
        if((left>=askl)&&(right<=askr))
        {
            lazy[now]+=addval;
            val[now]+=addval;
            return 0;
        }
        int mid=(left+right)>>1;
        change(now<<1,left,mid,askl,askr,addval);
        change(now<<1|1,mid+1,right,askl,askr,addval);
        updata(now);
        return 0;
    }
};

data d[maxn+10];
tree t;

int main()
{
    scanf("%d%d%d",&n,&m,&k);
    for(int i=1; i<=n; i++)
    {
        scanf("%d%d%d",&d[i].l,&d[i].r,&d[i].lim);
        d[i].r--;
    }
    std::sort(d+1,d+n+1);
    t.build(1,1,m);
    for(int i=1; i<=n; i++)
    {
        int tt=t.ask(1,1,m,d[i].l,d[i].r);
        //tt代表当前区间最多能上几头牛
        if(tt>d[i].lim)
        {
            tt=d[i].lim;
        }
        if(tt>0)
        //如果这一批牛能够上车
        {
            t.change(1,1,m,d[i].l,d[i].r,-tt);
            //将当前区间的值减去能够上车的牛的数量
            ans+=tt;
            //更新答案
        }
    }
    printf("%d\n",ans);
    return 0;
}