bzoj1492

好题+神题，首先肯定是dp，我们设f[i]为到第i天能获得的最多的B卷（设获得的钱数亦可）
由题目hint可知，要么全买要么全卖，我们有
f[i]=max(maxmoney,f[j]*b[i]+f[j]*rate[j]*a[i]))/(a[i]*rate[i]+b[i]),
这式子一看就是斜率优化，maxmoney可以先不管它
考虑决策j,k不妨设j<k，如果决策k优于j那么有
f[j]*b[i]+f[j]*rate[j]*a[i]<f[k]*b[i]+f[k]*rate[k]*a[i]
可以得到(f[k]*rate[k]-f[j]*rate[j])/(f[k]-f[j])>-b[i]/a[i]
我们设每个点是（f[k],f[k]*rate[k]),G(j,k)=(f[k]*rate[k]-f[j]*rate[j])/(f[k]-f[j])就是斜率
很明显我们要维护一个上凸壳，但这里我们不能用单调队列，因为后面不是单调的
可以用平衡树维护，但是我们观察这个式子
后面状态不会对前面状态产生影响（修改独立），并且不强制在线
于是我们可以用cdq分治来解决这个问题，我们还是根据天数顺序（状态）进行分治
分治过程中关键就是算[l,mid]部分整体对后面[mid+1.r]部分的影响
要能快速计算需要两个东西，首先我们要维护一个凸壳，
其次我们要按照单调的顺序处理后面部分的-b[]/a[]，这样我们可以用单调队列来做，
我们可以先对-b[]/a[]降序排序（上凸线相邻两点间的斜率是递减的）
然后先递归处理处于左边（状态时[l,mid]）的点，
在对一个区间都处理完毕之后，我们对这之间的点x为第一关键字排序，y为第二关键字排序
这样我们就能得到就得到了[l,mid]这部分状态排好序的点，然后我们维护单调队列，算出[l,mid]整体对[mid+1,r]的影响
然后我们再递归处理右边，完来之后再排序对[l,r]整体排序
在处理排序的时候，很很明显我们可以用归并排序，这样每次递归时处理得复杂度都是O(L) L是区间长度
所以根据主定理，T(n)=2T(n/2)+O(n) 复杂度是O(nlogn);
注意这道题凸线会挂精度，到底在什么时候要保留精度呢？请求指教

 const eps=1e-9;
 type node=record
        a,b,ra,k,x,y:double;
        po:longint;
      end;

 var a,b:array[..] of node;
     f:array[..] of double;
     q:array[..] of longint;
     i,n:longint;

 function getk(x,y:longint):double;
   begin
     if abs(a[y].x-a[x].x)<eps then exit(1e21);
     exit((a[y].y-a[x].y)/(a[y].x-a[x].x));
   end;

 function cmp(a,b:node):boolean;
   begin
     exit((a.x<b.x) or (abs(a.x-b.x)<eps) and (a.y<b.y));
   end;

 function max(a,b:double):double;
   begin
     if a>b then exit(a) else exit(b);
   end;

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

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

 procedure cdq(l,r:longint);
   var m,i,l1,l2,t,j:longint;
   begin
     if l=r then
     begin
       f[l]:=max(f[l],f[l-]);  //这里f[]代表的是钱数
       a[l].x:=f[l]/(a[l].ra*a[l].a+a[l].b);  //获得B券的数目
       a[l].y:=a[l].x*a[l].ra;
       exit;
     end;
     m:=(l+r) shr ;
     l1:=l; l2:=m+;
     for i:=l to r do  //先处理左部分的状态
       if a[i].po<=m then
       begin
         b[l1]:=a[i];
         inc(l1);
       end
       else begin
         b[l2]:=a[i];
         inc(l2);
       end;
     for i:=l to r do a[i]:=b[i];
     cdq(l,m);

     t:=;
     for i:=l to m do
     begin
       while (t>) and (getk(q[t-],q[t])<getk(q[t-],i)+eps) do dec(t);  //维护凸壳
       inc(t); q[t]:=i;
     end;
     j:=;
     for i:=m+ to r do
     begin
       while (j<t) and (getk(q[j],q[j+])+eps>a[i].k) do inc(j); //计算影响（就是找第一个小于的斜率的左端点）
       f[a[i].po]:=max(f[a[i].po],a[q[j]].x*a[i].b+a[q[j]].y*a[i].a);
     end;

     cdq(m+,r);
     l1:=l; l2:=m+;
     for i:=l to r do  //归并排序
       if ((l2>r) or cmp(a[l1],a[l2])) and (l1<=m) then
       begin
         b[i]:=a[l1];
         inc(l1);
       end
       else begin
         b[i]:=a[l2];
         inc(l2);
       end;

     for i:=l to r do a[i]:=b[i];
   end;

 begin
   readln(n,f[]);
   for i:= to n do
   begin
     readln(a[i].a,a[i].b,a[i].ra);
     a[i].k:=-a[i].b/a[i].a;
     a[i].po:=i;
   end;
   sort(,n);
   cdq(,n);
   writeln(f[n]::);
 end.