【Hihocoder1034】毁灭者问题（splay，树状数组）

题意：

假设你拥有 n 个魔法单位，他们从左到有站在一行，编号从 1 到 n。 每个单位拥有三项属性：

 

• si: 初始法力。

• mi: 最大法力上限。

• ri: 每秒中法力回复速度。

 

现在你操纵一个毁灭者，有 m 个操作，t l r，表示时刻 t，毁灭者对所有编号从 l 到 r 的单位，使用了魔法吸收。操作按照时间顺序给出，计算毁灭者一共吸收了多少法力。

 

n<=10^5 s[i],m[i],r[i]<=10^5 m<=10^5 maxtime<=10^9

 

思路：RYZ作业

因为每个人的回复速度不同且都有上限，所以不能用线段树完成

转换思路，不能维护每个人的魔法值，就应该维护时间点与时间间隔

考虑单位i，假设它回满的时间长为man,那么它对答案的贡献就是s1*r[i]+s2*m[i]

其中s1为<man的间隔的总和，s2为>=man的间隔的个数

现在问题转化成：

时间间隔需要维护插入，删除，子树大小和子树和，平衡树即可

时间点需要维护前驱，后继，插入，删除，我用树状数组，每次操作O(log^2 n)，如果用平衡树可以达到O(log n)

需要注意的是查询[0,man-1]这段区间时需要找到第一个>man-1的位置，而查询[man,oo]这段时需要找到最后一个<man的位置，所以rank函数不能共用

总复杂度O(m log^2 n)，维护时间时使用平衡树可以达到O(m log n)

不过m,n只有100000，煮不在糊

话说这个OJ不能用P交，那只能用对拍了

 

var t:array[0..300000,0..1]of longint;
    size,fa,l1,l2,l3,r1,r2,r3,
    x,y,z,c,time,t1,t2,t3,s,m,r,q:array[0..300000]of longint;
    sum,num:array[0..300000]of int64;
    n,i,que,head,tail,up,k,tot,root,cnt,k1,k2,man,kk,tmp,j:longint;
    ans1,ans2,s1,s2:int64;
    flag:boolean;

procedure swap(var x,y:longint);
var t:longint;
begin
 t:=x; x:=y; y:=t;
end;

procedure pushup(x:longint);
var l,r:longint;
begin
 l:=t[x,0]; r:=t[x,1];
 size[x]:=size[l]+size[r]+1;
// size[x]:=size[l]+size[r];
 sum[x]:=sum[l]+sum[r];
 if (num[x]<>maxlongint)and(num[x]<>-1) then sum[x]:=sum[x]+num[x];
end;

procedure rotate(x:longint;var k:longint);
var y,z,l,r:longint;
begin
 y:=fa[x]; z:=fa[y];
 if t[y,0]=x then l:=0
  else l:=1;
 r:=l xor 1;
 if y<>k then
 begin
  if t[z,0]=y then t[z,0]:=x
   else t[z,1]:=x;
 end
  else k:=x;
 fa[x]:=z; fa[y]:=x; fa[t[x,r]]:=y;
 t[y,l]:=t[x,r]; t[x,r]:=y;
 pushup(y);
 pushup(x);
end;

procedure splay(x:longint;var k:longint);
var y,z:longint;
begin
 while x<>k do
 begin
  y:=fa[x]; z:=fa[y];
  if y<>k then
  begin
   if (t[y,0]=x)xor(t[z,0]=y) then rotate(x,k)
    else rotate(y,k);
  end
   else k:=x;
  rotate(x,k);
 end;
end;

function kth(x:longint):longint;
var k,tmp:longint;
begin
 k:=root;
 while true do
 begin
  tmp:=size[t[k,0]]+1;
  if tmp=x then exit(k);
  if tmp>x then k:=t[k,0]
   else
   begin
    k:=t[k,1]; x:=x-tmp;
   end;
 end;
end;

function pred(x:longint):longint;
var k,last:longint;
begin
 k:=root; last:=num[root];
 while k<>0 do
 begin
  if num[k]<x then begin last:=num[k]; k:=t[k,1]; end
   else k:=t[k,0];
 end;
 exit(last);
end;

function succ(x:longint):longint;
var k,last:longint;
begin
 k:=root; last:=maxlongint;
 while k<>0 do
 begin
  if num[k]>x then begin last:=num[k]; k:=t[k,0]; end
   else k:=t[k,1];
 end;
 exit(last);
end;

function rank(x:longint):longint;
var k:longint;
begin
 if x=-1 then exit(1);
 x:=pred(x);
 k:=root; rank:=0;
 while k>0 do
 begin
  if num[k]<=x then begin rank:=rank+size[t[k,0]]+1; k:=t[k,1]; end
   else k:=t[k,0];
 end;
 inc(rank);
end;

procedure ins(x:longint);
var k,l,r:longint;
begin
 if x=0 then exit;
// if x<0 then begin writeln('error ',i);  exit; end;
 k:=rank(x);
 l:=kth(k-1);
 r:=kth(k);
 splay(l,root);
 splay(r,t[root,1]);
 k:=t[root,1];
 inc(cnt); t[k,0]:=cnt; fa[cnt]:=k;
 size[cnt]:=1;  num[cnt]:=x; sum[cnt]:=x;
 inc(tot);
// writeln('ins ',x,' ',tot);
end;

procedure del(x:longint);
var k,l,r,k1,k2:longint;
begin
 if x=0 then exit;
 k:=rank(x);
 l:=kth(k-1);
 r:=kth(k+1);
 splay(l,root);
 splay(r,t[root,1]);
 k1:=t[root,1]; k2:=t[k1,0];
 size[k1]:=size[t[k1,1]]+1;
 //sum[k1]:=sum[t[k1,1]]+num[k1];
 sum[k1]:=sum[t[k1,1]];
 if (num[k1]<>maxlongint)and(num[k1]<>-1) then sum[k1]:=sum[k1]+num[k1];
 fa[k2]:=0; sum[k2]:=0;  size[k2]:=0;
 t[k2,0]:=0; t[k2,1]:=0; num[k2]:=0;
 t[k1,0]:=0;
 dec(tot);
 //writeln('del ',x,' ',tot);
end;

function lowbit(x:longint):longint;
begin
 exit(x and (-x));
end;

function sumbit(x:longint):longint;
begin
 sumbit:=0;
 while x>0 do
 begin
  sumbit:=sumbit+q[x];
  x:=x-lowbit(x);
 end;
end;

procedure add(x,s:longint);
begin
 while x<=200000 do
 begin
  q[x]:=q[x]+s;
  x:=x+lowbit(x);
 end;
end;

procedure qsort1(l,r:longint);
var mid,i,j:longint;
begin
 i:=l; j:=r; mid:=l1[(l+r)>>1];
 repeat
  while mid>l1[i] do inc(i);
  while mid<l1[j] do dec(j);
  if i<=j then
  begin
   swap(l1[i],l1[j]);
   swap(r1[i],r1[j]);
   swap(t1[i],t1[j]);
   inc(i); dec(j);
  end;
 until i>j;
 if l<j then qsort1(l,j);
 if i<r then qsort1(i,r);
end;

procedure qsort2(l,r:longint);
var mid,i,j:longint;
begin
 i:=l; j:=r; mid:=r2[(l+r)>>1];
 repeat
  while mid>r2[i] do inc(i);
  while mid<r2[j] do dec(j);
  if i<=j then
  begin
   swap(l2[i],l2[j]);
   swap(r2[i],r2[j]);
   swap(t2[i],t2[j]);
   inc(i); dec(j);
  end;
 until i>j;
 if l<j then qsort2(l,j);
 if i<r then qsort2(i,r);
end;

function findkth(x:longint):longint;
var l,r,mid,last,tmp:longint;
begin
 l:=1; r:=200000; last:=0;
 while l<=r do
 begin
  mid:=(l+r)>>1;
  tmp:=sumbit(mid);
  {if tmp<=x then begin last:=mid; l:=mid+1; end
   //else r:=mid-1;     }
  if tmp>x then r:=mid-1
   else if tmp<x then begin last:=mid;  l:=mid+1 end
    else if tmp=x then begin last:=mid; r:=mid-1; end;

 end;
 if sumbit(last)<x then inc(last);
 exit(last);
end;

{function findkth(x:longint):longint;
var ret,p:longint;
begin
 p:=1<<17; ret:=0;
 while p>0 do
 begin
  if q[ret+p]<=x then
  begin
   ret:=ret+p;
   x:=x-q[ret];
  end;
  p:=p>>1;
 end;
 exit(ret);
end;  }

function hash(x:longint):longint;
var l,r,mid,last:longint;
begin
 l:=1; r:=up; last:=0;
 while l<=r do
 begin
  mid:=(l+r)>>1;
  if time[mid]=x then exit(mid)
   else if time[mid]>x then r:=mid-1
    else l:=mid+1;
 end;
 //exit(last);
end;

function querymn(x:longint):int64;
var k1,k2:longint;
begin
 k1:=kth(1);
 k2:=kth(rank(succ(x-1)));
 splay(k1,root);
 splay(k2,t[root,1]);
 exit(sum[t[k2,0]]);
// exit(size[t[k2,0]]);
end;

function querymx(x:longint):int64;
var k1,k2,s:longint;
begin
 k1:=pred(x);
 k:=root; s:=0;
 while k>0 do
 begin
  if num[k]<=k1 then begin s:=s+size[t[k,0]]+1; k:=t[k,1]; end
   else k:=t[k,0];
 end;

 k1:=kth(s);
 k2:=kth(tot);
 splay(k1,root);
 splay(k2,t[root,1]);
 exit(size[t[k2,0]]);
end;

function min(x,y:longint):longint;
begin
 if x<y then exit(x);
 exit(y);
end;

function max(x,y:longint):longint;
begin
 if x>y then exit(x);
 exit(y);
end;

begin
 assign(input,'data.in'); reset(input);
 assign(output,'hihocoder1034.out'); rewrite(output);
 readln(n);
 for i:=1 to n do read(s[i],m[i],r[i]);
 readln(que);
 for i:=1 to que do
 begin
  read(x[i],y[i],z[i]);
  inc(x[i]);
 end;
 l1:=y; r1:=z; t1:=x;
 l2:=y; r2:=z; t2:=x;
 l3:=y; r3:=z; t3:=x;
 qsort1(1,que);
 qsort2(1,que);

 if time[1]=1 then begin time[1]:=1; up:=1; end
  else begin time[1]:=1; time[2]:=t3[1]; up:=2; end;
 for i:=2 to que do
  if t3[i]<>time[up] then begin inc(up); time[up]:=t3[i]; end;
 inc(up); time[up]:=maxlongint;
 add(1,1);
 add(200000,1);
 num[1]:=maxlongint; size[1]:=2;
 t[1,0]:=2;
 num[2]:=-1; fa[2]:=1; size[2]:=1;
 root:=1; cnt:=2; tot:=2;
 //for i:=1 to que do c[i]:=hash(x[i]);
 head:=1; tail:=1;

 for i:=1 to n do
 begin


  if r[i]=0 then man:=maxlongint-1
   else
   begin
    if m[i] mod r[i]=0 then man:=m[i] div r[i]
     else man:=m[i] div r[i]+1;
   end;

  while (head<=que)and(i>=l1[head]) do
  begin
   kk:=hash(t1[head]);
   k:=sumbit(kk-1)+1;
   k1:=findkth(k-1);
   k2:=findkth(k);
   ins(t1[head]-time[k1]);
   if k2<>200000 then ins(time[k2]-t1[head]);
   if k2<>200000 then del(time[k2]-time[k1]);
   add(kk,1); inc(head);
  end;

  while (tail<=que)and(i>r2[tail]) do
  begin
   kk:=hash(t2[tail]);
   k:=sumbit(kk-1)+1;
   k1:=findkth(k-1);
   k2:=findkth(k+1);
   if k2<>200000 then ins(time[k2]-time[k1]);
   del(t2[tail]-time[k1]);
   if k2<>200000 then del(time[k2]-t2[tail]);
   add(kk,-1); inc(tail);
  end;


  s1:=querymn(man);
  s2:=querymx(man);
  ans1:=ans1+s1*r[i]+s2*m[i];

 { s1:=0;
  for j:=1 to cnt do
   if (num[j]<>0)and(num[j]<man) then inc(s1);
  s2:=0;
  for j:=1 to cnt do
   if (num[j]<>0)and(num[j]>=man) then inc(s2);

  ans2:=ans2+s1*r[i]+s2*m[i];                   }
  k:=findkth(2);
  if k<>200000 then
  begin
   tmp:=time[k];
   s1:=tmp-1;
   s1:=s1*r[i];
   if m[i]<s1 then s1:=m[i]; //start with 0
   s2:=tmp-1;
   s2:=s2*r[i]+s[i];
   if m[i]<s2 then s2:=m[i]; //start with s[i]
   ans1:=ans1-s1+s2;
  end;
 // writeln(ans1);
  //writeln(ans2);

 end;

 writeln(ans1);

 close(input);
 close(output);
end.