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

最新推荐文章于 2018-07-16 15:17:03 发布

Icefox_zhx

最新推荐文章于 2018-07-16 15:17:03 发布

阅读量338

点赞数

分类专栏： bzoj ---------dp----------- 决策单调性 CDQ分治

本文链接：https://blog.csdn.net/Icefox_zhx/article/details/77102420

版权

bzoj 同时被 3 个专栏收录

764 篇文章 1 订阅

订阅专栏

---------dp-----------

304 篇文章 2 订阅

订阅专栏

决策单调性

27 篇文章 0 订阅

订阅专栏

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

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

分析一下这句话：首先是卖出假设我们手中有一堆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;
}

Icefox_zhx

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
bzoj1492 [NOI2007]货币兑换Cash(斜率优化+CDQ分治)

这个大坑，终于填上了=，= 首先理论来自论文，点此查看题目很长。。耐心读。。首先我们注意到这句话： **必然存在一种最优的买卖方案满足：每次买进操作使用完所有的人民币；每次卖出操作卖出所有的金券。** 分析一下这句话：首先是卖出假设我们手中有一堆A券和一堆B券选择在一些天数分天卖出，那么这些天中一定有一天，卖出同样比例的证券可以获得的钱最多，我们选择这一天全部卖出一定比分天卖出更优
复制链接

扫一扫