bzoj3524 bzoj2223

bzoj3524这是我主席树的第一题

什么是主席树呢，就是n棵线段树，每棵线段树记录前缀每个数值（显然想到里离散化）出现次数

由于第i棵树相对于第i-1棵树只有logS个点不同（S为数值的种类数）

所以总的空间复杂度为O(nlogS)，非常好理解；

由于每棵线段树的形态都是一样的，所以这些线段树是可以做减法的，

这是一个非常有用的性质，也很好的解决了区间的性质

然后解决这道题，这题问区间出现次数超过(r-l+1)/2的数，显然直接顺着主席树搜就可以了logS的复杂度

bzoj2223基本同样的题目，注意样例n后面多了个ai的范围

 type node=record
        l,r,s:longint;
      end;

 var tree:array[..] of node;
     sum,head,a,b,rank,sa:array[..] of longint;
     x,y,i,n,m,t,len,p:longint;

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

 procedure sort(l,r: longint);
   var i,j,x: longint;
   begin
     i:=l;
     j:=r;
     x:=a[(l+r) shr ];
     repeat
       while a[i]<x do inc(i);
       while x<a[j] do dec(j);
       if not(i>j) then
       begin
         swap(a[i],a[j]);
         swap(b[i],b[j]);
         inc(i);
         j:=j-;
       end;
     until i>j;
     if l<j then sort(l,j);
     if i<r then sort(i,r);
   end;

 procedure update(x:longint);
   begin
     tree[x].s:=tree[tree[x].l].s+tree[tree[x].r].s;
   end;

 function build(l,r:longint):longint;
   var m,q:longint;
   begin
     inc(t);
     q:=t;
     if l=r then exit(t)
     else begin
       m:=(l+r) shr ;
       tree[q].l:=build(l,m);
       tree[q].r:=build(m+,r);
     end;
     exit(q);
   end;

 function pre(w,l,r:longint):longint;
   var m,q:longint;
   begin
     inc(t);
     q:=t;
     if l=r then
       tree[t].s:=sum[l]
     else begin
       m:=(l+r) shr ;
       if rank[i]<=m then
       begin
         tree[q].l:=pre(tree[w].l,l,m);
         tree[q].r:=tree[w].r;
       end
       else begin
         tree[q].l:=tree[w].l;
         tree[q].r:=pre(tree[w].r,m+,r);
       end;
       update(q);
     end;
     exit(q);
   end;

 function ask(x,y,l,r:longint):longint;
   var m,a,b:longint;
   begin
     if l=r then
     begin
       if tree[y].s-tree[x].s>len then
         exit(sa[l])
       else exit();
     end
     else begin
       m:=(l+r) shr ;
       if tree[y].s-tree[x].s<=len then exit();
       a:=tree[x].l;
       b:=tree[y].l;
       if tree[b].s-tree[a].s>len then exit(ask(a,b,l,m));
       a:=tree[x].r;
       b:=tree[y].r;
       if tree[b].s-tree[a].s>len then exit(ask(a,b,m+,r));
       exit();
     end;
   end;

 begin
   readln(n,m);
   for i:= to n do
   begin
     read(a[i]);
     b[i]:=i;
   end;
   sort(,n);
   p:=;
   rank[b[]]:=;
   sa[]:=a[];
   for i:= to n do
   begin
     if a[i]<>a[i-] then
     begin
       inc(p);
       sa[p]:=a[i];
     end;
     rank[b[i]]:=p;
   end;
   t:=;
   head[]:=build(,p);
   for i:= to n do
   begin
     inc(sum[rank[i]]);
     head[i]:=pre(head[i-],,p);
   end;
   for i:= to m do
   begin
     readln(x,y);
     len:=(y-x+) shr ;
     writeln(ask(head[x-],head[y],,p));
   end;
 end.