bzoj 3711: [PA2014]Druzyny 分治+线段树优化dp

题意

体育课上，n个小朋友排成一行（从1到n编号），老师想把他们分成若干组，每一组都包含编号连续的一段小朋友，每个小朋友属于且仅属于一个组。
第i个小朋友希望它所在的组的人数不多于d[i]，不少于c[i]，否则他就会不满意。
在所有小朋友都满意的前提下，求可以分成的组的数目的最大值，以及有多少种分组方案能达到最大值。
1<=n<=1000000，方案数量对1000000007取模

分析

真的是十分牛逼的一道题，比赛的时候只会打暴力。
设$f[i]$表示把前$i$个小朋友分组的最大组数。
首先我们可以求出$g[i]$表示最小的$j$使得对于任意$j<k<=i$都有$i-min(d[1..k])+1<=k$。
换句话说就是最小的$j$使得在只考虑$d[i]$这个限制的前提下$f[j,i-1]$都是可以转移到$f[i]$的。
不难发现$g[i]$是单调不降的，所以可以用单调队列来求。
那么$d[i]$的限制就没了，现在考虑如何处理$c[i]$的限制。
考虑分治，对于分治区间$[l,r]$，设$c[k]$等于$max(c[l+1,r])$。
设$solve(l,r)$表示处理$f[l,k-1]$到$f[k,r]$的转移。
先递归处理$solve(l,k-1)$，那么对于$solve(l,r)$的每一次转移，$c[i]$的限制都是相同的，也就等于$c[k]$。
接下来把所有转移分情况处理。
若$g[i]>=k$表示无法转移，直接退出即可。
若$l<=g[i]<k$，那么我们可以在线段树上区间查询。
若$g[i]<l且i<k+c[k]$，那么$i$每往后移一位，可以转移的位置就增加一个，只要开一个变量来$O(1)$维护就好了。
若$g[i]<l且i>=k+c[k]$，不难发现满足该条件的位置是连续的，且能到这些位置的转移是一样的，所以可以二分出右端点然后在线段树上区间修改。
下面来分析一下复杂度：
对于第二种情况，由于转移到$i$的每个区间互不相交，所以必然只有一个区间$[l,r]$满足$l<=g[i]<=r$，所以总的复杂度是$O(nlogn)$。
第三种情况的复杂度是$O(min(k-l,r-k+1))$。
第四种情况的复杂度是$O(logn)$。
于是总的复杂度就是$T(n)=T(n-x)+T(x)+logn+min(x,n-x)$。
咋一看不好分析，但后面那个$min(x,n-x)$可以看成分治结构从底向上合并，那不就是启发式合并的复杂度么？
所以总的复杂度就是$O(nlogn)$。

代码

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;

const int N=1000005;
const int inf=1000000000;
const int MOD=1000000007;

int n,c[N],d[N],g[N],q[N],tim;
struct data{int mx,s;}f[N];
struct tree{int c;data f,tag;}t[N*4];

int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

data merge(data a,data b,int f)
{
    if (b.mx==-1) return a;
    if (b.mx+f>a.mx) a=b,a.mx+=f;
    else if (b.mx+f==a.mx) a.s+=b.s,a.s-=a.s>=MOD?MOD:0;;
    return a;
}

void pushdown(int d)
{
    if (t[d].tag.mx==-1) return;
    data w=t[d].tag;t[d].tag=(data){-1,0};
    t[d*2].tag=merge(t[d*2].tag,w,0);
    t[d*2].f=merge(t[d*2].f,w,1);
    t[d*2+1].tag=merge(t[d*2+1].tag,w,0);
    t[d*2+1].f=merge(t[d*2+1].f,w,1);
}

void build(int d,int l,int r)
{
    t[d].tag=t[d].f=(data){-1,0};
    if (l==r) {t[d].c=l;return;}
    int mid=(l+r)/2;
    build(d*2,l,mid);build(d*2+1,mid+1,r);
    t[d].c=c[t[d*2].c]>c[t[d*2+1].c]?t[d*2].c:t[d*2+1].c;
}

void ins(int d,int l,int r,int x)
{
    if (l<r) pushdown(d);
    if (l==r) {f[l]=t[d].f=merge(t[d].f,f[l],0);return;}
    int mid=(l+r)/2;
    if (x<=mid) ins(d*2,l,mid,x);
    else ins(d*2+1,mid+1,r,x);
    t[d].f=merge(t[d*2].f,t[d*2+1].f,0);
}

int findc(int d,int l,int r,int x,int y)
{
    if (l<r) pushdown(d);
    if (l==x&&r==y) return t[d].c;
    int mid=(l+r)/2;
    if (y<=mid) return findc(d*2,l,mid,x,y);
    else if (x>mid) return findc(d*2+1,mid+1,r,x,y);
    else
    {
        int c1=findc(d*2,l,mid,x,mid),c2=findc(d*2+1,mid+1,r,mid+1,y);
        return c[c1]>c[c2]?c1:c2;
    }
}

data findf(int d,int l,int r,int x,int y)
{
    if (l<r) pushdown(d);
    if (x>y) return (data){-1,0};
    if (l==x&&r==y) return t[d].f;
    int mid=(l+r)/2;
    if (y<=mid) return findf(d*2,l,mid,x,y);
    else if (x>mid) return findf(d*2+1,mid+1,r,x,y);
    else return merge(findf(d*2,l,mid,x,mid),findf(d*2+1,mid+1,r,mid+1,y),0);
}

void modify(int d,int l,int r,int x,int y,data now)
{
    if (l<r) pushdown(d);
    if (l==x&&r==y) {t[d].tag=merge(t[d].tag,now,0);t[d].f=merge(t[d].f,now,1);return;}
    int mid=(l+r)/2;
    if (y<=mid) modify(d*2,l,mid,x,y,now);
    else if (x>mid) modify(d*2+1,mid+1,r,x,y,now);
    else modify(d*2,l,mid,x,mid,now),modify(d*2+1,mid+1,r,mid+1,y,now);
    t[d].f=merge(t[d*2].f,t[d*2+1].f,0);
}

int binary(int l,int r,int k)
{
    while (l<=r)
    {
        int mid=(l+r)/2;
        if (g[mid]<k) l=mid+1;
        else r=mid-1;
    }
    return l-1;
}

void solve(int l,int r)
{
    if (l==r) {ins(1,0,n,l);return;}
    int k=findc(1,0,n,l+1,r);
    solve(l,k-1);
    data now=findf(1,0,n,max(l,g[k]),max(k-c[k],l));
    for (int i=max(k,l+c[k]),j;i<=r;i++)
    {
        if (g[i]>=k) break;
        if (g[i]>=l) f[i]=merge(f[i],findf(1,0,n,g[i],min(k-1,i-c[k])),1);
        else if (i<k+c[k]-1) f[i]=merge(f[i],now,1),now=merge(now,i-c[k]+1>=l?f[i-c[k]+1]:(data){-1,0},0);
        else j=binary(i,r,l),modify(1,0,n,i,j,now),i=j;
    }
    solve(k,r);
}

void get_g()
{
    int head=1,tail=0,j=0;
    for (int i=1;i<=n;i++)
    {
        while (head<=tail&&d[q[tail]]>=d[i]) tail--;
        q[++tail]=i;
        while (i-d[q[head]]>j)
        {
            j++;
            while (head<=tail&&q[head]<=j) head++;
        }
        g[i]=j;
    }
}

int main()
{
    n=read();
    for (int i=1;i<=n;i++) c[i]=read(),d[i]=read(),f[i].mx=-1;
    get_g();
    f[0]=(data){0,1};
    build(1,0,n);
    solve(0,n);
    if (!f[n].s) puts("NIE");
    else printf("%d %d",f[n].mx,f[n].s);
    return 0;
}