poj3378

统计长度为5的上升序列个数，

容易想到O(n^2)的dp

f[k,i]:=Σf[k-1,j] (1<=j<i,a[i]>a[j])

ans：=Σf[5,i]

但是显然会超时，需要考虑优化

怎样快速找到所有比当前高度小的状态的和呢？

答案很显然：树状数组

考虑到这题每个数<=10^9，我们要将其离散化，再映射到树状数组上

注意这题的最终答案爆int64，所以要用到高精度

 var f,tr:array[..,..] of int64; //tr[i,j]表示树状数组，序列长度为i时，末尾离散化后高度为j；树状数组不会爆int64
     ans,d:array[..] of integer;
     a,b,c:array[..] of longint;
     len,k,n,i,j:longint;

 function lowbit(x:longint):longint;
   begin
     exit(x and (-x));
   end;

 procedure add(z:int64);       //高精度加法
   var i,la,w,x:longint;
   begin
     fillchar(d,sizeof(d),);
     la:=;
     while z<> do
     begin
       la:=la+;
       d[la]:=z mod ;
       z:=z div ;
     end;
     if la>len then len:=la;
     inc(len);
     w:=;
     for i:= to len do
     begin
       x:=w+d[i]+ans[i];
       ans[i]:=x mod ;
       w:=x div ;
     end;
     if ans[len]= then dec(len);
   end;

 function sum(p,q:longint):int64;
   begin
     sum:=;
     while p> do
     begin
       sum:=sum+tr[q,p];
       p:=p-lowbit(p);
     end;
   end;

 procedure work(p,q,z:int64);   //将当前状态加入树状数组
   begin
     while p<=n do
     begin
       tr[q,p]:=tr[q,p]+z;
       p:=p+lowbit(p);
     end;
   end;

 begin
   while not eof do
   begin
     readln(n);
     fillchar(c,sizeof(c),);
     fillchar(tr,sizeof(tr),);
     fillchar(f,sizeof(f),);
     for i:= to n do
     begin
       read(a[i]);
       b[i]:=i;
     end;
     readln;
     sort(,n);
     c[b[]]:=;
     k:=;
     for i:= to n do    //离散化，注意重复的标相同的号
       if a[i]=a[i-] then
         c[b[i]]:=c[b[i-]]
       else begin
         inc(k);
         c[b[i]]:=k;
       end;
     fillchar(ans,sizeof(ans),);
     len:=;
     for i:= to n do
     begin
       f[,i]:=;
       work(c[i],,);
       for j:= to  do
       begin
         f[j,i]:=sum(c[i]-,j-);    //dp
         if f[j,i]> then work(c[i],j,f[j,i]);  
       end;
       if f[,i]> then add(f[,i]);
     end;
     for i:=len downto  do
       write(ans[i]);
     writeln;
   end;
 end.

总复杂度为O(nlogn)

质量很高的一道题

var f,tr:array[0..5,0..50010] of int64; //tr[i,j]表示树状数组，序列长度为i时，末尾离散化后高度为j；树状数组不会爆int64

ans,d:array[0..100] of integer;

a,b,c:array[0..50010] of longint;

len,k,n,i,j:longint;

function lowbit(x:longint):longint;

begin

exit(x and (-x));

end;

procedure add(z:int64);       //高精度加法

var i,la,w,x:longint;

begin

fillchar(d,sizeof(d),0);

la:=0;

while z<>0 do

begin

la:=la+1;

d[la]:=z mod 10;

z:=z div 10;

end;

if la>len then len:=la;

inc(len);

w:=0;

for i:=1 to len do

begin

x:=w+d[i]+ans[i];

ans[i]:=x mod 10;

w:=x div 10;

end;

if ans[len]=0 then dec(len);

end;

function sum(p,q:longint):int64;

begin

sum:=0;

while p>0 do

begin

sum:=sum+tr[q,p];

p:=p-lowbit(p);

end;

end;

procedure work(p,q,z:int64);   //将当前状态加入树状数组

begin

while p<=n do

begin

tr[q,p]:=tr[q,p]+z;

p:=p+lowbit(p);

end;

end;

begin

while not eof do

begin

readln(n);

fillchar(c,sizeof(c),0);

fillchar(tr,sizeof(tr),0);

fillchar(f,sizeof(f),0);

for i:=1 to n do

begin

read(a[i]);

b[i]:=i;

end;

readln;

sort(1,n);

c[b[1]]:=1;

k:=1;

for i:=2 to n do    //离散化，注意重复的标相同的号

if a[i]=a[i-1] then

c[b[i]]:=c[b[i-1]]

else begin

inc(k);

c[b[i]]:=k;

end;

fillchar(ans,sizeof(ans),0);

len:=1;

for i:=1 to n do

begin

f[1,i]:=1;

work(c[i],1,1);

for j:=2 to 5 do

begin

f[j,i]:=sum(c[i]-1,j-1);    //dp

if f[j,i]>0 then work(c[i],j,f[j,i]);

end;

if f[5,i]>0 then add(f[5,i]);

end;

for i:=len downto 1 do

write(ans[i]);

writeln;

end;

end.