[洛谷1868]饥饿的奶牛

思路：

动态规划。
类似于线段覆盖，首先对每个区间的右端点从小到大排好序。
对于每个区间$s_i$，状态转移方程为$f_{s_i.r}=\max\limits_{0\leq j\leq s_i.l}\{f_j\}$。
对于这个$max$，我们可以用一个树状数组来维护前缀最大值。
有$n$组区间，区间范围是$0\sim m$，渐近时间复杂度为$O(n\log m)$。
另外注意区间有可能为$0$，用树状数组不好维护，因此我们可以将所有的端点$+1$。

#include<cstdio>
#include<cctype>
#include<cstring>
#include<algorithm>
inline int getint() {
    char ch;
    while(!isdigit(ch=getchar()));
    int x=ch^'0';
    while(isdigit(ch=getchar())) x=(((x<<2)+x)<<1)+(ch^'0');
    return x;
}
const int N=150000,M=3000002;
int m=0;
class FenwickTree {
    private:
        int val[M];
        int lowbit(const int x) {
            return x&-x;
        }
    public:
        FenwickTree() {
            memset(val,0,sizeof val);
        }
        void modify(int p,const int x) {
            while(p<=m) {
                val[p]=std::max(val[p],x);
                p+=lowbit(p);
            }
        }
        int query(int p) {
            int ret=0;
            while(p) {
                ret=std::max(ret,val[p]);
                p-=lowbit(p);
            }
            return ret;
        }
};
FenwickTree t;
int f[M]={0};
struct Segment {
    int x,y;
    bool operator < (const Segment &another) const {
        return y<another.y;
    }
};
Segment s[N];
int main() {
    int n=getint();
    for(register int i=0;i<n;i++) {
        s[i].x=getint()+1;
        s[i].y=getint()+1;
        m=std::max(m,s[i].y);
    }
    std::sort(&s[0],&s[n]);
    int ans=0;
    for(register int i=0;i<n;i++) {
        int &x=s[i].x,&y=s[i].y;
        int tmp=t.query(x-1)+y-x+1;
        if(tmp>f[y]) {
            t.modify(y,f[y]=tmp);
            ans=std::max(ans,tmp);
        }
    }
    printf("%d\n",ans);
    return 0;
}