bzoj4028

一眼分块题……

分块，维护每个块的总的gcd和xor和

先思考我们应该怎么查询，考虑到gcd是一个神奇的东西，因为它最多变化logX次

于是我们从前往后扫描每个块，如果一个块内总的gcd是当前扫描的前缀gcd的倍数

那么，也就意味着这个块里的每个位置所对应的前缀的gcd都等于当前gcd

因此，我们设当前xor和为nowxor,gcd为nowgcd，partxor为块内某个块前缀xor和

nowxor xor partxor*nowgcd=x 即 nowxor xor (x/nowgcd)=partxor

这时候只要查询块内是否存在某个块前缀xor和为nowxor xor (x/nowgcd)即可，这我们可以用hash解决

如果不是倍数关系，那么我们直接暴力这个块即可，这样的暴力一定不会超过logX次

至于修改，我们直接暴力重构对应块即可

const mo=124367;
type node=record
       po,num,next:longint;
     end;

var e:array[0..6010010] of node;
    p:array[0..320,0..mo] of longint;
    a,g,b,be:array[0..100010] of longint;
    size,t,len,i,j,n,m,x,y:longint;
    z:int64;
    ch:char;
    s:string;

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

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

procedure work(x,y,z:longint);
  var i,j:longint;
  begin
    i:=p[x,y mod mo];
    while i<>0 do
    begin
      j:=e[i].po;
      if e[i].po=y then
      begin
        e[i].num:=min(e[i].num,z);
        exit;
      end;
      i:=e[i].next;
    end;
    inc(len);
    e[len].po:=y;
    e[len].num:=z;
    e[len].next:=p[x,y mod mo];
    p[x,y mod mo]:=len;
  end;

procedure del(x,y,z:longint);
  var i,j:longint;
  begin
     i:=p[x,y mod mo];
    while i<>0 do
    begin
      j:=e[i].po;
      if e[i].po=y then
      begin
        if e[i].num=z then e[i].num:=n+1;
        exit;
      end;
      i:=e[i].next;
    end;
  end;

function get(x,y:longint):longint;
  var i,j:longint;
  begin
    i:=p[x,y mod mo];
    while i<>0 do
    begin
      j:=e[i].po;
      if j=y then exit(e[i].num);
      i:=e[i].next;
    end;
    exit(n+1);
  end;

function ask(x:int64):longint;
  var tg,tx,i,j,r,p:longint;
  begin
    tg:=0; tx:=0;
    for i:=1 to size do
    begin
      tg:=gcd(tg,a[i]);
      tx:=tx xor a[i];
      if int64(tg)*int64(tx)=x then exit(i);
      if x div int64(tg)>1 shl 30 then exit(-1);
    end;
    for i:=2 to t do
    begin
      if x div int64(tg)>1 shl 30 then exit(-1);
      if i=t then r:=n else r:=i*size;
      if g[r] mod tg=0 then
      begin
        if x mod tg=0 then
        begin
          p:=get(i,tx xor (x div int64(tg)));
          if p<=n then exit(p);
        end;
        tx:=tx xor b[r];
      end
      else begin
        for j:=(i-1)*size+1 to r do
        begin
          tg:=gcd(tg,a[j]);
          tx:=tx xor a[j];
          if int64(tg)*int64(tx)=x then exit(j);
          if x div int64(tg)>1 shl 30 then exit(-1);
        end;
      end;
    end;
    exit(-1);
  end;

begin
  readln(n);
  size:=trunc(sqrt(n));
  for i:=1 to n do
  begin
    read(a[i]);
    be[i]:=(i-1) div size+1;
  end;
  t:=n div size;
  if n mod size<>0 then inc(t);
  for i:=1 to n do
  begin
    if i mod size=1 then
    begin
      g[i]:=a[i];
      b[i]:=a[i];
    end
    else begin
      b[i]:=b[i-1] xor a[i];
      g[i]:=gcd(g[i-1],a[i]);
    end;
    work(be[i],b[i],i);
  end;
  readln(m);
  for i:=1 to m do
  begin
    s:='';
    read(ch);
    while ch<>' ' do
    begin
      s:=s+ch;
      read(ch);
    end;
    if s[1]='M' then
    begin
      readln(x,y);
      inc(x);
      a[x]:=y;
      for j:=x to min(size*be[x],n) do
      begin
        del(be[x],b[j],j);
        if j mod size=1 then
        begin
          b[j]:=a[j];
          g[j]:=a[j];
        end
        else begin
          b[j]:=b[j-1] xor a[j];
          g[j]:=g[j-1] xor a[j];
        end;
        work(be[x],b[j],j);
      end;
    end
    else begin
      readln(z);
      x:=ask(z);
      if x=-1 then writeln('no') else writeln(x-1);
    end;
  end;
end.