BZOJ3711 PA2014Druzyny（动态规划+cdq分治+线段树）

　　显然可以dp：设f[i]为前i个人最多能分多少组，则f[i]=max{f[j]}+1 (c_max<=i-j<=d_min)。

　　容易发现d的限制是一段连续区间，二分或者随便怎么搞都行。c则有点麻烦，考虑分治。找到区间中c最大的位置，处理左边区间再向右边（包括该位置）转移，最后处理右边区间（当然就是cdq分治）。

　　考虑怎么转移。设当前区间为[l,r]，分段点为k，处理的左边位置为i，右边位置j的限制区间为[a_j,j-1]，a_j单调不降。若i能更新j，则满足i+c_k<=j且i>=a_j。显然j<l+c_k或a_j>=k的点是无法被转移到的。

　　讨论一波。对于a_j<=l的区间，开始一段右端点每次+1，查询一次后每次O(1)更新；后面一段都是整个区间转移，直接在线段树上打标记。这样保证了是O(较小区间)，也就保证了分治的复杂度。a[j]>l的暴力在线段树上查询，因为对于每个j这只会出现一次，复杂度也很正确。

　　不停地调分治结果发现线段树不停出锅，可能连线段树都不会写了，没救。（当然发现分治也出锅了

　　非常卡空间。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<queue>
#include<vector>
using namespace std;
int read()
{
    int x=,f=;char c=getchar();
    while (c<''||c>'') {if (c=='-') f=-;c=getchar();}
    while (c>=''&&c<='') x=(x<<)+(x<<)+(c^),c=getchar();
    return x*f;
}
#define N 1000010
#define P 1000000007
int n,c[N],d[N],tree1[N<<];
priority_queue<int,vector<int>,greater<int> > q,qdel;
void inc(int &x,int y){x+=y;if (x>=P) x-=P;}
struct data{int x,y;}tree[N<<],lazy[N<<],f[N];
void upd(data &a,data b)
{
    if (b.x>a.x) a=b;
    else if (b.x==a.x) inc(a.y,b.y);
}
void down(int k,int L,int R)
{
    int mid=L+R>>;
    upd(tree[k<<],(data){lazy[k].x,1ll*(mid-L+)*lazy[k].y%P});
    upd(tree[k<<|],(data){lazy[k].x,1ll*(R-mid)*lazy[k].y%P});
    upd(lazy[k<<],lazy[k]);
    upd(lazy[k<<|],lazy[k]);
    lazy[k]=(data){,};
}
data merge(data p,data q)
{
    if (p.x<&&q.x<) return p;
    if (p.x>q.x) return p;
    else if (p.x<q.x) return q;
    return (data){p.x,(p.y+q.y)%P};
}
data query(int k,int l,int r,int L,int R)
{
    if (l>r) return (data){-N,};
    if (L==l&&R==r) return tree[k];
    if (lazy[k].x) down(k,L,R);
    int mid=L+R>>;
    if (r<=mid) return query(k<<,l,r,L,mid);
    else if (l>mid) return query(k<<|,l,r,mid+,R);
    else return merge(query(k<<,l,mid,L,mid),query(k<<|,mid+,r,mid+,R));
}
void modify(int k,int l,int r,data p,int L,int R)
{
    if (l>r) return;
    if (L==l&&R==r)
    {
        if (p.x>tree[k].x) tree[k].x=p.x,tree[k].y=1ll*p.y*(r-l+)%P,lazy[k]=p;
        else if (p.x==tree[k].x) inc(tree[k].y,1ll*p.y*(r-l+)%P),lazy[k].x=p.x,inc(lazy[k].y,p.y);
        return;
    }
    if (lazy[k].x) down(k,L,R);
    int mid=L+R>>;
    if (r<=mid) modify(k<<,l,r,p,L,mid);
    else if (l>mid) modify(k<<|,l,r,p,mid+,R);
    else modify(k<<,l,mid,p,L,mid),modify(k<<|,mid+,r,p,mid+,R);
    tree[k]=merge(tree[k<<],tree[k<<|]);
}
int query2(int k,int l,int r,int L,int R)
{
    if (L==l&&R==r) return tree1[k];
    int mid=L+R>>;
    if (r<=mid) return query2(k<<,l,r,L,mid);
    else if (l>mid) return query2(k<<|,l,r,mid+,R);
    else
    {
        int x=query2(k<<,l,mid,L,mid),y=query2(k<<|,mid+,r,mid+,R);
        if (c[x]>c[y]) return x;else return y;
    }
}
void build(int k,int l,int r)
{
    if (l==r) {tree1[k]=l;tree[k]=f[l];return;}
    int mid=l+r>>;
    build(k<<,l,mid);
    build(k<<|,mid+,r);
    tree1[k]=c[tree1[k<<]]>c[tree1[k<<|]]?tree1[k<<]:tree1[k<<|];
    tree[k]=merge(tree[k<<],tree[k<<|]);
}
void pre()
{
    int x=;
    for (int i=;i<=n;i++)
    {
        q.push(d[i]);
        while (!qdel.empty()&&q.top()==qdel.top()) q.pop(),qdel.pop();
        while (q.top()+x<i) qdel.push(d[++x]);
        tree1[i]=x;
    }
    while (!q.empty()) q.pop();
    while (!qdel.empty()) qdel.pop();
    for (int i=;i<=n;i++) d[i]=tree1[i];
    build(,,n);
}
void solve(int l,int r)
{
    if (l==r&&l)
    {
        data p=query(,l,l,,n);
        if (p.x<=f[l].x) modify(,l,l,f[l],,n);
        if (p.x>=f[l].x) upd(f[l],p);
    }
    if (l>=r) return;
    int k=query2(,l+,r,,n);
    solve(l,k-);
    if (d[k]<k)
    {
        data p=query(,l,k-c[k]-,,n);
        for (int i=max(l+c[k],k);i<=r&&d[i]<=l&&i<=k-+c[k];i++)
        {
            upd(p,f[i-c[k]]);
            upd(f[i],(data){p.x+,p.y});
        }
        int L=k,R=r,t=k-;
        while (L<=R)
        {
            int mid=L+R>>;
            if (d[mid]<=l) t=mid,L=mid+;
            else R=mid-;
        }
        modify(,k+c[k],t,(data){p.x+,p.y},,n);
        for (int i=t+;d[i]<=k-&&i<=r;i++)
        {
            p=query(,d[i],min(i-c[k],k-),,n);
            upd(f[i],(data){p.x+,p.y});
        }
    }
    solve(k,r);
}
int main()
{
#ifndef ONLINE_JUDGE
    freopen("bzoj3711.in","r",stdin);
    freopen("bzoj3711.out","w",stdout);
    const char LL[]="%I64d\n";
#else
    const char LL[]="%lld\n";
#endif
    n=read();
    for (int i=;i<=n;i++) c[i]=read(),d[i]=read();
    f[].x=,f[].y=;
    for (int i=;i<=n;i++) f[i].x=-N,f[i].y=;
    pre();
    solve(,n);
    if (f[n].x>=) cout<<f[n].x<<' '<<f[n].y<<endl;
    else cout<<"NIE";
    return ;
}