[BZOJ1492][NOI2007]货币兑换Cash-斜率优化DP-CDQ分治

货币兑换Cash

Description

小Y最近在一家金券交易所工作。该金券交易所只发行交易两种金券：A纪念券（以下简称A券）和 B纪念券（以下简称B券）。每个持有金券的顾客都有一个自己的帐户。金券的数目可以是一个实数。每天随着市场的起伏波动，两种金券都有自己当时的价值，即每一单位金券当天可以兑换的人民币数目。我们记录第 K 天中 A券 和 B券 的价值分别为 AK 和 BK（元/单位金券）。为了方便顾客，金券交易所提供了一种非常方便的交易方式：比例交易法。

比例交易法分为两个方面：
（a）卖出金券：顾客提供一个 [0,100] 内的实数 OP 作为卖出比例，其意义为：将OP% 的 A券和 OP% 的 B券 以当时的价值兑换为人民币；
（b）买入金券：顾客支付 IP 元人民币，交易所将会兑换给用户总价值为 IP 的金券，并且，满足提供给顾客的A券和B券的比例在第 K 天恰好为 RateK；

例如，假定接下来 3 天内的 Ak、Bk、RateK 的变化分别为：

假定在第一天时，用户手中有 100元 人民币但是没有任何金券。用户可以执行以下的操作：

注意到，同一天内可以进行多次操作。小Y是一个很有经济头脑的员工，通过较长时间的运作和行情测算，他已经知道了未来N天内的A券和B券的价值以及Rate。他还希望能够计算出来，如果开始时拥有S元钱，那么N天后最多能够获得多少元钱。

Input

输入第一行两个正整数N、S，分别表示小Y能预知的天数以及初始时拥有的钱数。接下来N行，第K行三个实数AK、BK、RateK，意义如题目中所述。对于100%的测试数据，满足：0 < AK ≤ 10；0 < BK ≤ 10；0 < RateK ≤ 100；MaxProfit ≤ 10^9。
【提示】
1.输入文件可能很大，请采用快速的读入方式。
2.必然存在一种最优的买卖方案满足：
每次买进操作使用完所有的人民币；
每次卖出操作卖出所有的金券。

Output

只有一个实数MaxProfit，表示第N天的操作结束时能够获得的最大的金钱数目。答案保留3位小数。

Sample Input

3 100
1 1 1
1 2 2
2 2 3

Sample Output

225.000

HINT

---

第一次写CDQ分治，同时也是第一次写斜率优化DP……
想想其实这两个方法早就能学会的啊……
以前居然纠结于为什么CDQ分治这样做是对的而不去看代码……

---

思路:
首先，这是一个dp。
然后，我们能得出转移方程:

令$f[i]$表示第$i$天的最大收益，则有:

$f[i]=max\{\frac{f[j]*(rate[j]*a[i]+b[i])}{a[j]*rate[j]+b[j]}\}$

上式的意义是，枚举之前的某一个日子用所有的钱买入券，今天卖出所有券所能得到的最大钱数。

那么我们得到了一个$O(n^2)$的dp……
根据数据，显然会T……
那么咱来试图优化一下这个dp吧。

如果我们现在在更新$f[i]$，要用$f[k]$代替之前的最优决策$f[j]$，那么有:

$\frac{f[k]*(rate[k]*a[i]+b[i])}{a[k]*rate[k]+b[k]} \geq \frac{f[j]*(rate[j]*a[i]+b[i])}{a[j]*rate[j]+b[j]}$

令$x[k]=\frac{f[k]*rate[k]}{a[k]*rate[k]+b[k]}$为第k天买入所能获得的最多的A券，
$y[k]=\frac{f[k]}{a[k]*rate[k]+b[k]}$为第k天买入所能获得的最多的B券。
很明显的一点是，$x[k]$和$y[k]$的值在$f[k]$被求出后就固定了。

那么上式变成:
$x[k]*a[i]+y[k]*b[i] \geq x[j]*a[i]+y[j]*b[i]$

简单粗暴，有没有?
化一化:

$\frac{y[j]-y[k]}{x[j]-x[k]} \leq -\frac{a[i]}{b[i]}$

那么把$-\frac{a[i]}{b[i]}$看做当前斜率，则我们就是要令点对$(x[j],y[j])$到$(x[k],y[k])$的斜率小于它，才能用$f[k]$来更新当前最优解。

很显然那么最优解在一个凸包上。
如果当前斜率单调的话，可以直接维护凸包，$O(n)$出解。
那么这就是斜率优化。

但是很遗憾，这题它的斜率不单调。
然而，我们可以让它尽量单调~
这可是个有序更新的dp呢~
那么，如果现在我们把原dp顺序序列拆成两半，那么是不是$[mid+1,r]$区间的更新顺序和$[l,mid]$区间的答案更新毫无关系?

这就是CDQ分治的核心思想
或者说，就是运用分治，让它有序。
对于一个区间$[l,r]$，我们先递归处理$[l,mid]$，此时我们已经得到了$[l,mid]$区间的最优解。
然后，我们用$[l,mid]$的最优解去更新$[mid+1,r]$。
最后，递归处理$[mid+1,r]$。

呃然而目前为止这不是跟普通dp没什么区别么?
事实上，咱几个月前也是这么想的。
然而，事实上，$[mid+1,r]$区间的更新顺序和$[l,mid]$区间的答案更新毫无关系。

所以，我们可以先递归处理$[l,mid]$，并把$[l,mid]$区间的答案先做成一个凸包，这对$[mid+1,r]$毫无影响。
然后可以把$[mid+1,r]$区间的询问按其斜率排好序，这对$[l,mid]$毫无影响。
之后，用刚做好的$[l,mid]$的凸包上的答案更新已经有序的$[mid+1,r]$，直接单调队列扫一遍就好。
接着，$[mid+1,r]$递归内部更新。
最后，$[l,r]$内部按坐标归并排序，为构造凸包做准备。
于是，神奇的事情发生了——我们的每次更新都是$O(n)$的!

那么，我们通过归并排序保证$[l,mid]$答案有序，$[mid+1,r]$询问有序，每层递归更新$O(n)$，递归分治$O(log n)$层，得到最终复杂度$O(nlogn)$。

是不是很棒呢~

对于这题，根据上述流程直接上CDQ分治就好~

#include<iostream>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>

using namespace std;

typedef double db;

const int N=120009;
const db eps=1e-7;
const db Inf=1e9;

struct query
{
    db a,b,rate,k;
    int id;
}q[N],qtmp[N];

inline bool operator <(query satori,query koishi)
{
    return satori.k<koishi.k;
}

struct coord
{
    db x,y;
}p[N],ptmp[N];

inline bool operator <(coord satori,coord koishi)
{
    return satori.x<koishi.x+eps || (fabs(satori.x-koishi.x)<eps && satori.y<koishi.y+eps);
}

int n,stk[N];
db f[N];

inline int read()
{
    int x=0,ff=1;char ch=getchar();
    while(ch<'0' || '9'<ch)
    {
        if(ch=='-')
            ff=-1;
        ch=getchar();
    }
    while('0'<=ch && ch<='9')
    {
        x=x*10+(ch^48);
        ch=getchar();
    }

    return x*ff;
}

inline db slope(int i,int j)
{
    if(i==0)
        return -Inf;
    if(j==0)
        return Inf;
    if(fabs(p[i].x-p[j].x)<=eps)
        return -Inf;
    return (p[i].y-p[j].y)/(p[i].x-p[j].x);
}

void solve(int l,int r)
{
    if(l==r)
    {
        f[l]=max(f[l],f[l-1]);
        p[l].y=f[l]/(q[l].a*q[l].rate+q[l].b);
        p[l].x=p[l].y*q[l].rate;
        return;
    }

    int mid=l+r>>1,l1=l,l2=mid+1;

    for(int i=l;i<=r;i++)
        if(q[i].id<=mid)
            qtmp[l1++]=q[i];
        else
            qtmp[l2++]=q[i];
    for(int i=l;i<=r;i++)
        q[i]=qtmp[i];

    solve(l,mid);

    int top=0;
    for(int i=l;i<=mid;i++)
    {
        while(top>=2 && slope(i,stk[top])+eps>slope(stk[top],stk[top-1]))
            top--;
        stk[++top]=i;
    }

    int top2=1;
    for(int i=r;i>=mid+1;i--)
    {
        while(top2<top && q[i].k<slope(stk[top2],stk[top2+1]))
            top2++;
        f[q[i].id]=max(f[q[i].id],p[stk[top2]].x*q[i].a+p[stk[top2]].y*q[i].b);
    }

    solve(mid+1,r);

    l1=l,l2=mid+1;
    for(int i=l;i<=r;i++)
        if((p[l1]<p[l2] || l2>r) && l1<=mid)
            ptmp[i]=p[l1++];
        else
            ptmp[i]=p[l2++];
    for(int i=l;i<=r;i++)
        p[i]=ptmp[i];

}

int main()
{
    scanf("%d%lf",&n,&f[0]);
    for(int i=1;i<=n;i++)
    {
        scanf("%lf%lf%lf",&q[i].a,&q[i].b,&q[i].rate);
        q[i].id=i;q[i].k=-q[i].a/q[i].b;
    }

    sort(q+1,q+n+1);
    solve(1,n);

    printf("%.3lf\n",f[n]);

    return 0;
}