题目的限制可以被描述为：
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
",f[n].x,f[n].s);
else puts("NIE");
}