[CQOI 2014] 数三角形 & 机械排序臂

program triangle;
var m,n,i,j:integer;
    ans,t:qword;

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

begin{main}
  readln(m,n);
  t:=(m+1)*(n+1);
  ans:=t*(t-1)*(t-2) div 6;
  for i:=0 to m do
    for j:=0 to n do
      if not ((i=0) and (j=0)) then
        begin
          if (i=0) or (j=0) then ans:=ans-(gcd(i,j)-1)*(m-i+1)*(n-j+1)
          else ans:=ans-2*(gcd(i,j)-1)*(m-i+1)*(n-j+1);
        end;
  writeln(ans);
end.

program sort3;
var n,i,root,c,x,t,temp:longint;
    f,ff,loc,l,fa,lc,rc,da,tot:array[0..100010] of longint;
    lazy:array[0..100010] of boolean;

function dd(x,xloc,y,yloc:longint):boolean;
begin
  if x<y then exit(true);
  if (x=y) and (xloc<yloc) then exit(true);
  exit(false);
end;

function gg(x,xloc,y,yloc:longint):boolean;
begin
  if x>y then exit(true);
  if (x=y) and (xloc>yloc) then exit(true);
  exit(false);
end;

procedure qsort(l,r:longint);
var mid,mid_loc,i,j,temp:longint;
begin
  i:=l;j:=r;mid:=f[(l+r) div 2];mid_loc:=loc[(l+r) div 2];
  while i<=j do
    begin
      while dd(f[i],loc[i],mid,mid_loc) do inc(i);
      while gg(f[j],loc[j],mid,mid_loc) do dec(j);
      if i<=j then
        begin
          temp:=f[i];f[i]:=f[j];f[j]:=temp;
          temp:=loc[i];loc[i]:=loc[j];loc[j]:=temp;
          inc(i);dec(j);
        end;
    end;
  if i<r then qsort(i,r);
  if l<j then qsort(l,j);
end;

procedure lrot(p:longint);
var q:longint;
begin
  q:=fa[p];fa[p]:=fa[q];
  if q=root then root:=p else
    if q=lc[fa[q]] then lc[fa[q]]:=p else rc[fa[q]]:=p;
  lc[q]:=rc[p];
  if rc[p]<>0 then fa[rc[p]]:=q;
  rc[p]:=q;
  fa[q]:=p;
  tot[q]:=tot[lc[q]]+tot[rc[q]]+1;
  tot[p]:=tot[lc[p]]+tot[rc[p]]+1;
end;

procedure rrot(p:longint);
var q:longint;
begin
  q:=fa[p];fa[p]:=fa[q];
  if q=root then root:=p else
    if lc[fa[q]]=q then lc[fa[q]]:=p else
      rc[fa[q]]:=p;
  rc[q]:=lc[p];
  if lc[p]<>0 then fa[lc[p]]:=q;
  lc[p]:=q;
  fa[q]:=p;
  tot[q]:=tot[lc[q]]+tot[rc[q]]+1;
  tot[p]:=tot[lc[p]]+tot[rc[p]]+1;
end;

procedure switch(p:longint);
var t:longint;
begin
  if lazy[p]=false then exit;
  t:=lc[p];lc[p]:=rc[p];rc[p]:=t;
  lazy[p]:=false;
  lazy[lc[p]]:=not lazy[lc[p]];
  lazy[rc[p]]:=not lazy[rc[p]];
end;

procedure clear(p:longint);
begin
  if p=root then
    begin
      if lazy[p] then switch(p);
      exit;
    end;
  clear(fa[p]);
  if lazy[p] then switch(p);
end;

procedure splay(p:longint);
var t,tt:longint;
begin
  while p<>root do
    begin
      if p=lc[fa[p]] then //p is lc
        begin
          if fa[p]=root then lrot(p) else
            if fa[p]=lc[fa[fa[p]]] then
              begin
                lrot(fa[p]);lrot(p);
              end
            else
              begin
                lrot(p);rrot(p);
              end;
        end
      else
        begin
          if fa[p]=root then rrot(p) else
            if fa[p]=rc[fa[fa[p]]] then
              begin
                rrot(fa[p]);rrot(p);
              end
            else
              begin
                rrot(p);lrot(p);
              end;
        end;
    end;
  fa[p]:=0;
end;

procedure insert(x:longint);
var t,tt:longint;
begin
  inc(c);
  fa[c]:=0;lc[c]:=0;rc[c]:=0;da[c]:=f[x];
  if root=0 then
    begin
      root:=c;
      tot[root]:=1;
    end
  else
    begin
      t:=root;
      repeat
        begin
          tt:=t;
          if loc[x]<loc[t] then
            begin
              inc(tot[t]);
              t:=lc[t];
            end
          else
            begin
              inc(tot[t]);
              t:=rc[t];
            end;
        end;
      until t=0;
      tot[x]:=1;
      if loc[x]<loc[tt] then lc[tt]:=c else rc[tt]:=c;
      fa[c]:=tt;
      splay(c);
    end;
end;

begin
  //assign(input,‘sort10.in‘);reset(input);
  //assign(output,‘sort10.out‘);rewrite(output);
  fillchar(lazy,sizeof(lazy),false);
  readln(n);
  for i:=1 to n do
    begin
      read(f[i]);
      loc[i]:=i;
    end;
  ff:=f;
  qsort(1,n);
  for i:=1 to n do
    begin
       f[i]:=i;
    end;
  for i:=1 to n do
    insert(i);     //buildtree
  for i:=1 to n do
    begin
      clear(i);
      splay(i);
      write(tot[lc[i]]+i,‘ ‘);
      lazy[lc[i]]:=not lazy[lc[i]]; //oh no I wrote‘:=true‘ and debuged for 3 days..
      t:=lc[i];
      if lazy[t] then switch(t);
      while rc[t]<>0 do
        begin
          t:=rc[t];
          if lazy[t] then switch(t);
        end;
      fa[rc[i]]:=0;fa[lc[i]]:=0;root:=lc[i];temp:=rc[i];tot[i]:=0;
      if lc[i]=0 then root:=rc[i];
      rc[i]:=0;lc[i]:=0;fa[i]:=0;
      if t<>0 then
        begin
          clear(t);//from down to top then top to down
          splay(t);
          fa[temp]:=t;rc[t]:=temp;tot[t]:=tot[t]+tot[rc[t]];
        end
    end;
  //close(input);close(output);
end.