poj3693

求连续重复次数最多的子串（字典序最小）

首先连续出现一次一定是可行的，我们考虑出现两次及以上

我们考虑穷举这个子串长度l，如果某个这个长度的子串出现了两次以上

那他一定包含包含某两个字符s[l*m+1],s[l*(m+1)+1]

这样，我们先判断每对字符能延伸多长（先求LCP，然后判断是否能再向前延伸）

穷举长度L 的时间是n，每次计算的时间是n/L。所以整个做法的时间复杂度是O(n/1+n/2+n/3+……+n/n)=O(nlogn)

var h,ans,y,x,sum,rank,sa:array[0..100010] of longint;
    f:array[0..100010,0..20] of longint;
    d:array[0..20] of longint;
    b,e,p,te,i,j,max,t,l,n,m:longint;
    s:ansistring;

function cmp(a,b,j:longint):boolean; //注意这里排序判断要这么写（因为多测）
  begin
    if y[a]<>y[b] then exit(true);
    if (a+j<=n) and (b+j<=n) and (y[a+j]<>y[b+j]) then exit(true);
    if (a+j<=n) and (b+j<=n) then exit(false)
    else exit(true);
  end;

procedure swap(var a,b:longint);
  var c:longint;
  begin
    c:=a;
    a:=b;
    b:=c;
  end;

function min(a,b:longint):longint;
  begin
    if a>b then exit(b) else exit(a);
  end;

procedure suffix;
  var i,j,p,m:longint;
  begin
    fillchar(sum,sizeof(sum),0);
    m:=255;
    for i:=1 to n do
    begin
      y[i]:=ord(s[i]);
      inc(sum[y[i]]);
    end;
    for i:=2 to m do
      inc(sum[i],sum[i-1]);
    for i:=n downto 1 do
    begin
      sa[sum[y[i]]]:=i;
      dec(sum[y[i]]);
    end;
    p:=1;
    rank[sa[1]]:=1;
    for i:=2 to n do
    begin
      if y[sa[i]]<>y[sa[i-1]] then inc(p);
      rank[sa[i]]:=p;
    end;
    m:=p;
    j:=1;
    while m<n do
    begin
      fillchar(sum,sizeof(sum),0);
      y:=rank;
      p:=0;
      for i:=n-j+1 to n do
      begin
        inc(p);
        x[p]:=i;
      end;
      for i:=1 to n do
        if sa[i]>j then
        begin
          inc(p);
          x[p]:=sa[i]-j;
        end;

      for i:=1 to n do
      begin
        rank[i]:=y[x[i]];
        inc(sum[rank[i]]);
      end;
      for i:=1 to m do
        inc(sum[i],sum[i-1]);
      for i:=n downto 1 do
      begin
        sa[sum[rank[i]]]:=x[i];
        dec(sum[rank[i]]);
      end;
      p:=1;
      rank[sa[1]]:=1;
      for i:=2 to n do
      begin
        if cmp(sa[i],sa[i-1],j) then inc(p);
        rank[sa[i]]:=p;
      end;
      m:=p;
      j:=j shl 1;
    end;
    p:=0;
    for i:=1 to n do
    begin
      if rank[i]=1 then continue;
      j:=sa[rank[i]-1];
      while (i+p<=n) and (j+p<=n) and (s[i+p]=s[j+p]) do inc(p);
      h[rank[i]]:=p;
      if p>0 then dec(p);
    end;
  end;

procedure rmq;
  var i,j,t:longint;
  begin
    t:=trunc(ln(n)/ln(2));
    d[0]:=1;
    for i:=1 to t do
      d[i]:=d[i-1]*2;
    for i:=1 to n do
      f[i,0]:=h[i];
    for j:=1 to t do
      for i:=1 to n do
        if i+d[j]-1<=n then
          f[i,j]:=min(f[i,j-1],f[i+d[j-1],j-1])
        else break;
  end;

function ask(x,y:longint):longint;
  var k:longint;
  begin
    if x>y then swap(x,y);
    inc(x);
    k:=trunc(ln(y-x+1)/ln(2));
    exit(min(f[x,k],f[y-d[k]+1,k]));
  end;

begin
  while true do
  begin
    inc(te);
    readln(s);
    if s='#' then break;
    n:=length(s);
    suffix;
    rmq;
    max:=1;
    ans[1]:=0;
    t:=1;
    for l:=1 to n do
    begin
      i:=1;
      while i+l<=n do
      begin
        p:=ask(rank[i],rank[i+l]);
        m:=p div l+1;
        j:=i-(l-p mod l); //判断是否能再向前延伸
        if (j>0) and (p mod l<>0) then
        begin
          if ask(rank[j],rank[j+l])>=p then
            inc(m);
        end;
        if m>max then
        begin
          max:=m;
          t:=1;
          ans[1]:=l;
        end
        else if (m=max) and (ans[t]<>l) then
        begin
          inc(t);
          ans[t]:=l;
        end;
        i:=i+l;
      end;
    end;
    b:=0; e:=0;
    for i:=1 to n do
    begin
      for j:=1 to t do
        if (sa[i]+ans[j]<=n) and (sa[i]+max*ans[j]-1<=n) and (ask(i,rank[sa[i]+ans[j]])>=(max-1)*ans[j]) then
        begin
          b:=sa[i];
          e:=b+max*ans[j]-1;
          break;
        end;

      if b<>0 then break;
    end;
    write('Case ',te,': ');
    for i:=b to e do
      write(s[i]);
    writeln;
  end;
end.