[PA2014]druzyny

题目的限制可以被描述为：
f_i=max(f_j)+1,\max(c_{j+1...i})<=i-j<=\min(d_{j+1...i})
分析一下性质。考虑i-j<=\min(d_{j+1...i})就是i<=j+\min(d_{j+1...i})
当j变大时，右边变大，当i变大时，左边变大，右边变小。
所以对于每个i,存在一个pre_i，使得pre_i~i-1的j都满足条件。
当i右移时，i的pre值变大，所以是个滑动窗口问题，使用单调队列维护。
但是\max(c_{j+1...i})<=i-j没有什么很好的性质。本人尝试单调栈失败。
考虑分治。找到某个区间[l,r]的最大值的位置k。
这样子的好处是max是一定的，但是坏处是时间复杂度可能错误。
根据分治套路使用[l,k-1]更新[k,r]
此时对于k~r的每个i，能更新到它的j满足pre_i<=j<=i-c[k]。
由于使用[l,k-1]更新[k,r]，所以能更新到某个i的区间满足max(pre_i,l)<=j<=min(i-c[k],k-1)。
min很麻烦，分类讨论把min去掉。
当pre_i>=k时，左边显然会>=k，无法更新。
而且当i增大，pre_i也增大，后面的值无法更新，所以直接退出。
同时，当i<l+c[k]，也不能更新答案。
这是因为当i=l+c[k]，j<=l，当i<l+c[k]，j<l。不符合条件
当l<=pre_i<k是，限制变为pre_i<=j<=min(i-c[k],k-1)
由于转移到i的区间互不相交，所以可以直接在线段树上区间查询，时间复杂度一次均摊log_2n，会进行n次。
当pre_i<l，限制变为l<=j<=min(i-c[k],k-1)
当i<k+c[k]即i-c[k]<k，限制变为l<=j<=i-c[k]。
这时候当i每右移一位，转移的位置就多一个，使用一个变量维护。
变量的值每次取max即可。它的初始值可以通过线段树查询得到
这样子，要符合要求，i最多移动min(k-l,r-k+1)次，这是两个数组启发式合并的复杂度，均摊时间复杂度nlog_2n+nlog_2n
当i>=k+c[k]即i-c[k]>=k，限制变为l<=j<k。
此时会发现pre_i<l的位置是连续的，且这些位置所能转移到的区间都是[l,k-1]
可以二分一下，然后区间的每个数=min(这个数,x)。时间复杂度一次log_2n，会进行n次。
可以使用一颗线段树完成。需要支持区间对一个值取min和求区间最大值。
由于只有区间最大值查询，不需要线段树beats。
综上，我们在nlog_2n时间复杂度，n空间复杂度内解决了这个问题。
被卡常的代码：

#include<bits/stdc++.h>
using namespace std;
#define N 4000010
#pragma GCC optimize(2)
%:pragma GCC optimize(3)
%:pragma GCC optimize("Ofast")
%:pragma GCC optimize("inline")
%:pragma GCC optimize("-fgcse")
%:pragma GCC optimize("-fgcse-lm")
%:pragma GCC optimize("-fipa-sra")
%:pragma GCC optimize("-ftree-pre")
%:pragma GCC optimize("-ftree-vrp")
%:pragma GCC optimize("-fpeephole2")
%:pragma GCC optimize("-ffast-math")
%:pragma GCC optimize("-fsched-spec")
%:pragma GCC optimize("unroll-loops")
%:pragma GCC optimize("-falign-jumps")
%:pragma GCC optimize("-falign-loops")
%:pragma GCC optimize("-falign-labels")
%:pragma GCC optimize("-fdevirtualize")
%:pragma GCC optimize("-fcaller-saves")
%:pragma GCC optimize("-fcrossjumping")
%:pragma GCC optimize("-fthread-jumps")
%:pragma GCC optimize("-funroll-loops")
%:pragma GCC optimize("-fwhole-program")
%:pragma GCC optimize("-freorder-blocks")
%:pragma GCC optimize("-fschedule-insns")
%:pragma GCC optimize("inline-functions")
%:pragma GCC optimize("-ftree-tail-merge")
%:pragma GCC optimize("-fschedule-insns2")
%:pragma GCC optimize("-fstrict-aliasing")
%:pragma GCC optimize("-fstrict-overflow")
%:pragma GCC optimize("-falign-functions")
%:pragma GCC optimize("-fcse-skip-blocks")
%:pragma GCC optimize("-fcse-follow-jumps")
%:pragma GCC optimize("-fsched-interblock")
%:pragma GCC optimize("-fpartial-inlining")
%:pragma GCC optimize("no-stack-protector")
%:pragma GCC optimize("-freorder-functions")
%:pragma GCC optimize("-findirect-inlining")
%:pragma GCC optimize("-fhoist-adjacent-loads")
%:pragma GCC optimize("-frerun-cse-after-loop")
%:pragma GCC optimize("inline-small-functions")
%:pragma GCC optimize("-finline-small-functions")
%:pragma GCC optimize("-ftree-switch-conversion")
%:pragma GCC optimize("-foptimize-sibling-calls")
%:pragma GCC optimize("-fexpensive-optimizations")
%:pragma GCC optimize("-funsafe-loop-optimizations")
%:pragma GCC optimize("inline-functions-called-once")
%:pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize("O3")
#define mo 1000000007
int n,c[N],d[N],pr[N],qu[N];
struct st{
	int mx[N],po;
	void bd(int o,int l,int r){
		if(l==r){
			mx[o]=l;
			return;
		}
		int md=(l+r)/2;
		bd(o*2,l,md);
		bd(o*2+1,md+1,r);
		mx[o]=mx[o*2+1];
		if(c[mx[o*2]]>c[mx[o*2+1]])
			mx[o]=mx[o*2];
	}
	void qu(int o,int l,int r,int x,int y){
		if(r<x||y<l)return;
		if(x<=l&&r<=y){
			if(c[mx[o]]>c[po])
				po=mx[o];
			return;
		}
		int md=(l+r)/2;
		qu(o*2,l,md,x,y);
		qu(o*2+1,md+1,r,x,y);
	}
	int qm(int l,int r){
		po=0;
		qu(1,0,n,l,r);
		return po;
	}
}sg;
struct no{
	int x,s;
}f[N],va[N],tg[N];
no operator+(no x,no y){
	if(x.x<y.x)
		return y;
	if(x.x>y.x)
		return x;
	return (no){x.x,(x.s+y.s)%mo};
}
no mg(no x,no y,int z){
	if(y.x==-1)
		return x;
	if(y.x+z==x.x)
		return(no){y.x+z,(x.s+y.s)%mo};
	if(y.x+z>x.x)
		return(no){y.x+z,y.s};
	return x;
}
void pd(int o){
	if(tg[o].x!=-1){
		tg[o*2]=tg[o*2]+tg[o];
		tg[o*2+1]=tg[o*2+1]+tg[o];
		va[o*2]=mg(va[o*2],tg[o],1);
		va[o*2+1]=mg(va[o*2+1],tg[o],1);
		tg[o].x=-1;
		tg[o].s=0;
	}
}
void mod(int o,int l,int r,int x,int y,no z){
	if(r<x||y<l)return;
	if(x<=l&&r<=y){
		tg[o]=tg[o]+z;
		va[o]=mg(va[o],z,1);
		return;
	}
	pd(o);
	int md=(l+r)/2;
	mod(o*2,l,md,x,y,z);
	mod(o*2+1,md+1,r,x,y,z);
	va[o]=va[o*2]+va[o*2+1];
}
no qq(int o,int l,int r,int x,int y){
	if(r<x||y<l)return(no){-1,0};
	if(x<=l&&r<=y)
		return va[o];
	pd(o);
	int md=(l+r)/2;
	return qq(o*2,l,md,x,y)+qq(o*2+1,md+1,r,x,y);
}
void mm(int o,int l,int r,int x){
	if(l==r){
		va[o]=va[o]+f[l];
		f[l]=va[o];
		return;
	}
	pd(o);
	int md=(l+r)/2;
	if(x<=md)
		mm(o*2,l,md,x);
	else mm(o*2+1,md+1,r,x);
	va[o]=va[o*2]+va[o*2+1];
}
int ef(int a,int b,int po){
	int l=a,r=b,ans;
	while(l<=r){
		int md=(l+r)/2;
		if(pr[md]<po){
			ans=md;
			l=md+1;
		}
		else r=md-1;
	}
	return ans;
}
void dfs(int l,int r){
	if(l==r){
		mm(1,0,n,l);
		return;
	}
	int k=sg.qm(l+1,r);
	dfs(l,k-1);
	no ans=qq(1,0,n,max(l,pr[k]),max(k-c[k],l));
	for(int i=max(k,l+c[k]);i<=r;i++){
		if(pr[i]>=k)break;
		if(l<=pr[i]&&pr[i]<k)
			f[i]=mg(f[i],qq(1,0,n,pr[i],min(i-c[k],k-1)),1);
		if(pr[i]<l){
			if(i-c[k]<k-1){
				f[i]=mg(f[i],ans,1);
				if(i-c[k]+1>=l)
					ans=ans+f[i-c[k]+1];
			}
			else{
				int po=ef(i,r,l);
				mod(1,0,n,i,po,ans);
				i=po;
			}
		}
	}
	dfs(k,r);
}
signed main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
		scanf("%d%d",&c[i],&d[i]);
	int h=1,t=0,j=0;
	for(int i=1;i<=n;i++){
		while(h<=t&&d[qu[t]]>=d[i])
			t--;
		qu[++t]=i;
		while(h<=t&&i-d[qu[h]]>j){
			j++;
			while(h<=t&&qu[h]<=j)
				h++;
		}
		pr[i]=j;
	}
	for(int i=1;i<N;i++)
		tg[i].x=va[i].x=-1;
	for(int i=1;i<=n;i++)
		f[i].x=-1;
	f[0]=(no){0,1};
	sg.bd(1,0,n);
	dfs(0,n);
	if(f[n].s)
		printf("%d %d\n",f[n].x,f[n].s);
	else puts("NIE");
}