动规里的偏序

动规转移是往往要满足一系列条件，其中可能只要满足单调的偏序关系，因此，在动归理论复杂度超时时，我们可以将这些偏序关系写出来，或用数据结构，或用维护斜率等一系列方法来维护这些偏序关系，降低复杂度。

例题：

给你一个长度为N的正整数序列A₁,A₂…A_N，你需要踢掉一些数（踢完了以后右边的数字自动往左补），使得踢完后满足A_i=i的数字尽量多。

很容易想出方程，f[i]:=max{f[j]}+1（f[i]指使a[i]为新序列第a[i]项最多能有几个数字满足条件），

偏序关系为：1、i>j

                        2、a[i]>a[j]

                        3、i-j>=a[i]-a[j] ——> i-a[i]>=j-a[j]

看起来像是三维偏序，但是，不难看出2、3可推出1，所以我们只需维护2、3的偏序关系

2可以快排初始化，3可以映射一个坐标轴，用线段树或树状数组在log n时间内完成转移，题目也就此解决。

虽然，现在我们可以很快构造出算法，但lmd同学考试时虽然也找出偏序关系，但一直认为是三维偏序，只好裸做。

因此，我们要明确我们要维护什么，要求什么，最好是写出来，探寻内部关系，不能漫无目的想算法。

var a,b:array[1..100000]of longint;
    f:array[1..262144]of longint;
    n,ans,m1:longint;
procedure qsort(l,r:longint);
var i,j,x,y,c:longint;
begin
 i:=l;j:=r;x:=a[(l+r)>>1];y:=b[(l+r)>>1];
 repeat
  while (a[i]<x)or((a[i]=x)and(b[i]>y)) do inc(i);
  while (x<a[j])or((x=a[j])and(y>b[j])) do dec(j);
  if not(i>j) then begin
   c:=a[i];a[i]:=a[j];a[j]:=c;
   c:=b[i];b[i]:=b[j];b[j]:=c;
   inc(i);dec(j)
  end
 until i>j;
 if i<r then qsort(i,r);
 if l<j then qsort(l,j)
end;
procedure change(x,y:longint);
begin
 x:=x+m1;
 while (x<>0)and(f[x]<y) do begin
  f[x]:=y;
  x:=x>>1
 end
end;
function ask(r:longint):longint;
var l:longint;
begin
 l:=1+m1-1;r:=r+m1+1;ask:=0;
 while not(l xor r=1) do begin
  if l and 1=0 then if f[l+1]>ask then ask:=f[l+1];
  if r and 1=1 then if f[r-1]>ask then ask:=f[r-1];
  l:=l>>1;r:=r>>1
 end
end;
procedure origin;
begin
 m1:=1;
 while m1<n+2 do m1:=m1<<1;m1:=m1-1
end;
procedure init;
var i,max:longint;
begin
 readln(n);
 for i:=1 to n do begin read(a[i]);b[i]:=i end;
 qsort(1,n);
 origin;
 ans:=0;
 for i:=1 to n do
 if b[i]>=a[i] then begin
  max:=ask(b[i]-a[i]+1)+1;
  change(b[i]-a[i]+1,max);
  if max>ans then ans:=max
 end;
 writeln(ans)
end;
begin
assign(input,'easyIV.in');reset(input);
assign(output,'easyIV.out');rewrite(output);
 init;
close(input);close(output)
end.