bzoj1492 [NOI2007]货币兑换Cash(斜率优化+CDQ分治)

这个大坑，终于填上了=，=
首先理论来自论文，点此查看
题目很长。。耐心读。。首先我们注意到这句话：

必然存在一种最优的买卖方案满足：
每次买进操作使用完所有的人民币；每次卖出操作卖出所有的金券。

分析一下这句话：首先是卖出假设我们手中有一堆A券和一堆B券 选择在一些天数分天卖出，那么这些天中一定有一天，卖出同样比例的证券可以获得的钱最多，我们选择这一天全部卖出 一定比分天卖出更优。

然后是买入 由于卖出是一天 对于任意一天卖出 我分开买 那么一定有一天花同样的钱买入证券后在那一天卖出获利最大，选择在那一天全部买入 一定比分天买入更优

故买入和卖出都是在一天完成，而且都是倾巢买入/卖出。

因此不难确立动态规划的方程：

设$f[i]$表示前$i$天的最大收益。

第j天将手中的钱全部换掉,可以换成的B券数目
$Y(j)=f[j]*\frac{1}{Rate[j]*A[j]+B[j]}$

第j天将手中的钱全部换掉,可以换成的A券数目
$X(j)=f[j]*\frac{Rate[j]}{Rate[j]*A[j]+B[j]}$

第i天将第j天买的AB券全部卖掉：$A[i]*X(j)+B[i]*Y(j)$
则$f[i]=max\{f[i-1],A[i]*X(j)+B[i]*Y(j)\}$

这样就有了一个$O(n^2)$的算法。(f[i]表示意思不太一样，这样好写)

$O(n^2)$版

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;
#define N 100010
int n,s;
double A[N],B[N],Rate[N],f[N],ans=0;//f[i]--第i天最多能买多少A券。 
int main(){
    freopen("a.in","r",stdin);
    scanf("%d%d",&n,&s);
    for(int i=1;i<=n;++i) scanf("%lf%lf%lf",&A[i],&B[i],&Rate[i]);
    f[1]=s*Rate[1]/(A[1]*Rate[1]+B[1]);
    for(int i=2;i<=n;++i){
        for(int j=1;j<i;++j)
            ans=max(ans,f[j]*A[i]+f[j]/Rate[j]*B[i]);
        f[i]=ans*Rate[i]/(A[i]*Rate[i]+B[i]);
    }
    printf("%.3lf",ans);
    return 0;
}

然而这样是过不了的，我们很自然的想到斜率优化.
设k1< k2且k1优于k2，
则 $B[i]*(Y[k1]-Y[k2])>A[i]*(X[k2]-X[k1])$，我们发现正负难以判定。。不如假设X[k2]>X[k1]，即X单增，则$\frac{Y[k2]-Y[k1]}{X[k2]-X[k1]}<-\frac{A[i]}{B[i]}$,然而-A[i]/B[i]并不是单调的。。。这就很讨厌了。。

简单好写的单调队列废掉了。怎么办呢？神犇表示拿平衡树维护一个凸线不就好了么。orz5k+的代码。难道我就只能这样去码平衡树了么。。不，你还可以用神奇的CDQ分治。

CDQ分治的思想是f[i]的决策点一定在0~i-1之中，于是我们分治，其中对于每一层递归[l,r]，二分出一个中点mid，然后递归求出[l,mid]中所有的f值，对[l,mid]中的点建立凸包，用[mid+1,r]中的所有元素的斜率去询问，得到[l,mid]中所有的点对[mid+1,r]中所有点的影响，然后递归求出[mid+1,r]中的所有f值，其中当我们递归到任意[i,i]时，0~i-1中所有点对这个点的影响都已经计算过，于是直接得出f[i]即可。

大体思路可以见论文，我就不在赘述了。只在此说点自己的理解。我们面对的问题无非就是a[i]/b[i]不单调，那我们给他排个序强制单调不就好了。。可是这样决策又不连续了，那我能不能把决策的影响分开统计？前一半的值是会影响后一半的，所以我们递归处理，更新影响。

时间复杂度为$T(n) = 2T(n/2) + O(n)$，因此算法的时间复杂度为$O(nlog^2n)$

用栈维护上凸壳版

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
#define N 100010
#define inf 1e20
#define eps 1e-8
int n,top=0,st[N];
double f[N];
struct point{
    double a,b,rate,k,x,y;int id;
}p[N],t[N];
inline bool cmp(point x,point y){
    return x.k>y.k;
}
inline double slope(int k1,int k2){
    if(!k2) return -inf;
    if(fabs(p[k1].x-p[k2].x)<eps) return inf;
    return (p[k2].y-p[k1].y)/(p[k2].x-p[k1].x);
}
void solve(int l,int r){//返回时，保证f[l]..f[r]均已求出 
    if(l==r){
        f[l]=max(f[l],f[l-1]);//第l天最多多少钱 
        p[l].y=f[l]/(p[l].a*p[l].rate+p[l].b);//第l天最多买b券 
        p[l].x=p[l].y*p[l].rate;return;//第l天最多买a券  
    }
    int mid=(l+r)>>1,l1=l,l2=mid+1,j=1;
    for(int i=l;i<=r;++i){//保证l...mid就是原来的l..mid，但是是按k值降序排序的 
        if(p[i].id<=mid) t[l1++]=p[i];
        else t[l2++]=p[i];
    }
    memcpy(p+l,t+l,sizeof(p[0])*(r-l+1));
    solve(l,mid);
    top=0;
    for(int i=l;i<=mid;++i){//构造上凸包，使斜率单降。 
        while(top>1&&slope(st[top],i)>slope(st[top-1],st[top])) --top;
        st[++top]=i;
    }st[++top]=0;//在后面补个0，防止越界 
    for(int i=mid+1;i<=r;++i){//mid+1...r是原来的mid+1...r按k值降序排列的，满足单调性，且l..mid均为它的决策 
        while(j<top&&slope(st[j],st[j+1])>p[i].k) ++j;
        f[p[i].id]=max(f[p[i].id],p[i].a*p[st[j]].x+p[i].b*p[st[j]].y);//找到在l..mid中的最优决策，更新。 
    }
    solve(mid+1,r);//递归解决右面。 
    l1=l,l2=mid+1;
    for(int i=l;i<=r;++i){//保证返回时l..r是按x升序排序的（为了满足我们的假设斜率单调） 
        if(l1<=mid&&(l2>r||p[l1].x<p[l2].x)) t[i]=p[l1++];
        else t[i]=p[l2++];
    }
    memcpy(p+l,t+l,sizeof(p[0])*(r-l+1));
}
int main(){
//  freopen("a.in","r",stdin);
    scanf("%d%lf",&n,&f[0]);
    for(int i=1;i<=n;++i){
        scanf("%lf%lf%lf",&p[i].a,&p[i].b,&p[i].rate);
        p[i].k=-p[i].a/p[i].b;p[i].id=i;
    }sort(p+1,p+n+1,cmp);//按k值降序排序 
    solve(1,n);
    printf("%.3lf",f[n]);
    return 0;
}

我个人觉得还是单调队列维护下凸壳顺手一些。。。

用单调队列维护下凸壳版

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
#define N 100010
#define inf 1e20
#define eps 1e-8
int n,top=0,q[N],h=1,t=0;
double f[N];
struct point{
    double a,b,rate,k,x,y;int id;
}p[N],pp[N];
inline bool cmp(point x,point y){
    return x.k<y.k;
}
inline double slope(int k1,int k2){
    if(!k2) return inf;
    if(fabs(p[k1].x-p[k2].x)<eps) return -inf;
    return (p[k1].y-p[k2].y)/(p[k2].x-p[k1].x);
}
void solve(int l,int r){
        f[l]=max(f[l],f[l-1]);
        p[l].y=f[l]/(p[l].a*p[l].rate+p[l].b);
        p[l].x=p[l].y*p[l].rate;return;
    }
    int mid=(l+r)>>1,l1=l,l2=mid+1;
    for(int i=l;i<=r;++i){
        if(p[i].id<=mid) pp[l1++]=p[i];
        else pp[l2++]=p[i];
    }
    memcpy(p+l,pp+l,sizeof(p[0])*(r-l+1));
    solve(l,mid);
    h=1,t=0;
    for(int i=l;i<=mid;++i){
        while(h<t&&slope(q[t],i)<slope(q[t-1],q[t])) --t;
        q[++t]=i;
    }
    for(int i=mid+1;i<=r;++i){
        while(h<t&&slope(q[h],q[h+1])<p[i].k) ++h;
        f[p[i].id]=max(f[p[i].id],p[i].a*p[q[h]].x+p[i].b*p[q[h]].y);
    }
    solve(mid+1,r);
    l1=l,l2=mid+1;
    for(int i=l;i<=r;++i){
        if(l1<=mid&&(l2>r||p[l1].x<p[l2].x)) pp[i]=p[l1++];
        else pp[i]=p[l2++];
    }
    memcpy(p+l,pp+l,sizeof(p[0])*(r-l+1));
}
int main(){
//  freopen("a.in","r",stdin);
    scanf("%d%lf",&n,&f[0]);
    for(int i=1;i<=n;++i){
        scanf("%lf%lf%lf",&p[i].a,&p[i].b,&p[i].rate);
        p[i].k=p[i].a/p[i].b;p[i].id=i;
    }sort(p+1,p+n+1,cmp);
    solve(1,n);
    printf("%.3lf",f[n]);
    return 0;
}