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[0..100010] of node;
    f:array[0..100010] of double;
    q:array[0..100010] 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 1].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-1]);  //这里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 1;
    l1:=l; l2:=m+1;
    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:=0;
    for i:=l to m do
    begin
      while (t>1) and (getk(q[t-1],q[t])<getk(q[t-1],i)+eps) do dec(t);  //维护凸壳
      inc(t); q[t]:=i;
    end;
    j:=1;
    for i:=m+1 to r do
    begin
      while (j<t) and (getk(q[j],q[j+1])+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+1,r);
    l1:=l; l2:=m+1;
    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[0]);
  for i:=1 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(1,n);
  cdq(1,n);
  writeln(f[n]:0:3);
end.