CERC 2013 Magical GCD

题目大意如下：给定一个序列，每个序列有值xi,现给定t个数列,对于每个长n的数列，求一段[l,r]使 [r-l+1]*gcd(l,r)最大，gcd(l,r)指的是该连续区间的最大公约数。

不难想到n^3,n^2logx,n^2的暴力吧

n^3DP，n^2logx暴力枚举，n^2DP

可以这样考虑，每次我对于某一个数，保存若干个值，以i为右端点的区间且gcd为某一值的时候这个区间最大的左端点位置是哪里？

但是你也许会认为这样做状态会不会有点多？更新是不是n方的呢？

其实不是的，因为我们可以从左到右来递推。

什么意思呢？对于每一个数，它与前面构成的gcd一定不会太多（约数肯定不会太多），所以我们最多也只需要保存每一个约数为gcd的时候左边最远能够拓展的位置。

其实远远不要保存每一个约数的位置，因为实际上很多的约数都不是gcd，这样我们就可以由左边的所有状态和右边的一个gcd一次来递推了。

当然，我们也可以直接利用指针的自动排序特性（类似链式前向星），我们碰到一个比当前(r-l+1)*val要小的就更新，因为我们再也尝试不到比它大的了。

{$inline on}

const maxn=;

type edge=^node;
    node=record
    next,last:edge;
    pos,val:int64;
end;

var head,tail:edge;
    e:array [..maxn] of edge;
    n,cnt:longint;
    ans:int64;
    f:array [..maxn] of int64;

procedure addedge(pos,value:int64); inline;
var p:edge;
begin
    inc(cnt);
    new(p);
    p^.next:=head^.next;
    p^.last:=head;
    p^.next^.last:=p;
    p^.last^.next:=p;
    p^.pos:=pos;
    p^.val:=value;
    e[cnt]:=p;
end;

procedure delete(var p:edge); inline;
begin
    p^.last^.next:=p^.next;
    p^.next^.last:=p^.last;
end;

procedure init; inline;
begin
    ans:=;
    cnt:=;
    head^.val:=; tail^.val:=;
    head^.next:=tail; tail^.last:=head;
    head^.last:=nil; tail^.next:=nil;
end;

function gcd(a,b:int64):int64; inline;
begin
    if a mod b= then exit(b)
    else exit(gcd(b,a mod b));
end;

function max(x,y:int64):int64; inline;
begin
   if x>y then exit(x)
   else exit(y);
end;

procedure main;
var t,value:int64;  i:longint; p:edge;
begin
    read(t);
    new(head); new(tail);
    while t<> do
        begin
            dec(t);
            init;
            read(n);
            ans:=;
                for i:= to n do
                    begin
                        read(value);
                        addedge(i,value);
                        p:=head^.next;
                            while p<>tail do
                                begin
                                    p^.val:=gcd(p^.val,value);
                                    ans:=max(ans,p^.val*(i-p^.pos+));
                                    if p^.val=p^.last^.val then delete(p^.last);
                                    p:=p^.next;
                                end;
                    end;
            writeln(ans);
        end;
end;

begin
      main;
end.