BZOJ 1492 货币兑换 Cash 平衡树维护凸包 CDQ分治

最新推荐文章于 2019-09-25 12:13:33 发布
最新推荐文章于 2019-09-25 12:13:33 发布
阅读量4.1k 收藏
点赞数 10
分类专栏： BZOJ 凸包 CDQ分治 Splay NOI 平衡树 斜率优化 文章标签： BZOJ BZOJ1492 斜率优化 平衡树 CDQ分治
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/popoqqq/article/details/38874839
版权
BZOJ 同时被 3 个专栏收录
667 篇文章 1 订阅
订阅专栏
NOI
27 篇文章 0 订阅
订阅专栏
凸包
12 篇文章 0 订阅
订阅专栏

题目大意：


这题真是为难了我1B。。。做了三天，两种方法都试过了一遍，真是膜拜NOI的神犇们能在一个多小时内干掉这道题

首先我们分析一下操作 首先是卖出

假设我们手中有一堆A券和一堆B券 选择在一些天数分天卖出

那么这些天中一定有一天，卖出同样比例的证券可以获得的钱最多

我们选择这一天全部卖出 一定比分天卖出更优

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

选择在那一天全部买入 一定比分天买入更优

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

然后。。这题一看就是斜率优化 连递推式都是P=A[i]*X[i]+B[i]*Y[i] 万事俱备 就是AB不单调！

斜率不单调其实也好办 反正是凸包 平衡树维护不就简单了

简单个熊啊！！！

第一天下午开始写，第二天早上还在调，下午才AC，写了足足5.5KB。。

SPLAY各种挂 调的我都快被SPLAY了

此外这题递推式不满足队列优化的条件、、只能在平衡树上找斜率，着实坑了我1B。。。

然后是代码 边界讨论那里写的有点累赘 见谅了

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define M 100100
#define null (&empty)
using namespace std;
typedef pair<double,double> point;
struct List{
    point p;
    double slope;
    List *last,*next;
}head;
typedef pair<int,List*> P;
struct abcd{
    point num;
    List *pos;
    int size;
    abcd*ls,*rs;
    void sizmaintain(){
        size=1;
        if(ls)size+=ls->size;
        if(rs)size+=rs->size;
    }
}empty,*root=null,*Tar;
void zig(abcd*&x)
{
    abcd*k=x->ls;
    x->ls=k->rs;
    k->rs=x;
    x=k;
    x->rs->sizmaintain();
    x->sizmaintain();
}
void zag(abcd*&x)
{
    abcd*k=x->rs;
    x->rs=k->ls;
    k->ls=x;
    x=k;
    x->ls->sizmaintain();
    x->sizmaintain();
}
void splay(abcd *&x,abcd **y)
{
    if(x==Tar)return ;
    if(x==*y)
    {
        if(x->ls==Tar){  zig(x); return ;  }
        else if(x->rs==Tar){  zag(x); return ;  }
    }
    if(x->ls->ls==Tar) zig(x),zig(x);
    else if(x->rs->rs==Tar) zag(x),zag(x);
    else if(x->ls->rs==Tar) zag(x->ls),zig(x);
    else if(x->rs->ls==Tar) zig(x->rs),zag(x);
}
void insert(abcd*&x,point y,List *z)
{
    Tar=x;
    if(x==null){
        Tar=x=new abcd;
        x->num=y;
        x->pos=z;
        x->size=1;
        x->ls=x->rs=null;
        return ;
    }
    x->size++;
    if(y<x->num)insert(x->ls,y,z);
    else insert(x->rs,y,z);
    splay(x,&root);
}
void update(abcd*&x,point y,abcd**z)
{
    int re=x->ls->size;
    if(y==x->num)
    {
        Tar=x;
        return ;
    }
    if(y<x->num) update(x->ls,y,z);
    else update(x->rs,y,z);
    splay(x,z);
}
List* pre(abcd*x,point y)
{
    if(x==null)return &head;
    if(y<=x->num)return pre(x->ls,y);
    List*z=pre(x->rs,y);
    if(z->p<x->num)    return x->pos;
    return z;
}
double getslope(point p1,point p2)
{
    if(p1.first==p2.first)
        return 2147483647*(p2.second>p1.second?1:-1);
    return (double)( p2.second-p1.second )/( p2.first-p1.first );
}
void insert_point(point p)
{
    if(!head.next)
    {
        List*temp=new List;
        head.next=temp;
        temp->p=p;
        temp->next=NULL;
        temp->last=&head;
        temp->slope=2147483647;
        insert(root,p,temp);
        return ;
    }
    List*pos=pre(root,p);
    if( pos->next && pos->next->p == p )
        return;
    if(pos==&head)
    {
        pos=head.next;
        while(1)
        {
            pos->slope = getslope( p , pos->p );
            if(!pos->next)
                break;
            if( pos->next->slope > pos->slope )
                pos=pos->next;
            else
                break;
        }
         
        List*temp=new List;
        temp->next=pos;
        pos->last=temp;
        head.next=temp;
        temp->last=&head;
        temp->p=p;
        temp->slope=2147483647;
        update(root,temp->next->p,&root);
        root->ls=null;
        root->sizmaintain();
        insert(root,p,temp);
        return ;
    }
    if(!pos->next)
    {
        List*temp=new List;
        while(1)
        {
            temp->slope = getslope( pos->p , p );
            if(pos->last==&head)
                break;
            if( temp->slope > pos->slope )
                pos=pos->last;
            else
                break;
        }
        pos->next=temp;
        temp->last=pos;
        temp->p=p;
        temp->next=NULL;
        update(root,pos->p,&root);
        root->rs=null;
        root->sizmaintain();
        insert(root,p,temp);
        return ;
    }
    List*pos2 = pos->next;
    if( getslope(pos->p,p) < getslope(p,pos2->p) )
        return ;
    List*temp = new List;
    while(1)
    {
        pos2->slope=getslope(p,pos2->p);
        if(!pos2->next)
            break;
        if( pos2->next->slope > pos2->slope )
            pos2=pos2->next;
        else
            break;
    }
    while(1)
    {
        temp->slope = getslope( pos->p , p );
        if(pos->last==&head)
            break;
        if( temp->slope > pos->slope )
            pos=pos->last;
        else
            break;
    }
    temp->p=p;
    temp->next=pos2;
    pos2->last=temp;
    temp->last=pos;
    pos->next=temp;
    update(root,pos->p,&root);
    update(root,pos2->p,&(root->rs) );
    root->rs->ls=null;
    root->rs->sizmaintain();
    root->sizmaintain();
    insert(root,p,temp);
}
List* getans(abcd *x,double y)//找到第一个斜率大于y的点
{
    head.next->slope=2147483647;
    if(x==null)return head.next;
    double s = x->pos->slope;
    if(y>=s)return getans(x->ls,y);
    List*z=getans(x->rs,y);
    if(z->slope>s)return x->pos;
    return z;
}
/*
List* pre(abcd*x,point y)
{
    if(x==null)return &head;
    if(y<=x->num)return pre(x->ls,y);
    List*z=pre(x->rs,y);
    if(z->p<x->num)    return x->pos;
    return z;
}
*/
double A[M],B[M],Rate[M],X[M],Y[M],f;
int n;
int main()
{
    int i;
     
    //freopen("cash.in","r",stdin);
    //freopen("cash.out","w",stdout);
     
    empty.ls=empty.rs=null;
    cin>>n>>f;
    for(i=1;i<=n;i++)
        scanf("%lf%lf%lf",&A[i],&B[i],&Rate[i]);
    for(i=1;i<=n;i++)
    {
        if(i!=1)
        {
            point p=getans( root , - A[i] / B[i] )->p;
            f=max( f , A[i] * p.first + B[i] * p.second );
        }
        X[i] = f / ( A[i] + B[i] / Rate[i] );
        Y[i] = f / ( A[i] * Rate[i] + B[i] );
        insert_point( make_pair( X[i] , Y[i] ) );
        //printf("%d %.3lf %.3lf %.3lf\n",i,f,X[i],Y[i]);
    }
    printf("%.3lf\n",f);
}

第二种方法就简单多了 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]即可

这个算法不难理解，但是我挂了半天。。CDQ没写错，sort居然写错了，按照Rate排了个序，眼科大夫死得早啊

最可怕的是前四个点居然还过了 这是要有多水的节奏

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define M 100100
using namespace std;
typedef pair<double,double> P;
int n,stack[M],top;
double f[M];
struct abcd{
    double A,B,Rate;
    double slope;
    int pos;
}q[M],nq[M];
bool operator < (abcd x,abcd y)
{
    return x.slope < y.slope;
}
P p[M],np[M];
double getslope(P x,P y)
{
    if(x.first==y.first)
        return 2147483647*(y.second>=x.second?1:-1);
    return (y.second-x.second)/(y.first-x.first);
}
void CDQ(int l,int r)
{
    int i,mid=l+r>>1;
    if(l==r)
    {
        f[mid]=max( f[mid] , f[mid-1] );
        p[mid].first = f[mid] / ( q[mid].A + q[mid].B / q[mid].Rate ) ;
        p[mid].second = f[mid] / ( q[mid].A * q[mid].Rate + q[mid].B ) ;
        return ;
    }
    int l1=l,l2=mid+1;
    for(i=l;i<=r;i++)
        if(q[i].pos<=mid)
            nq[l1++]=q[i];
        else
            nq[l2++]=q[i];
    memcpy( q+l , nq+l , sizeof(q[0])*(r-l+1) );
    CDQ(l,mid);
    top=0;
    for(i=l;i<=mid;i++)
    {
        while(top>1)
            if( getslope(p[stack[top-1]],p[stack[top]]) < getslope(p[stack[top]],p[i]) )
                stack[top--]=0;
            else
                break;
        stack[++top]=i;
    }
    for(i=mid+1;i<=r;i++)
    {
        while(top>1)
            if( getslope(p[stack[top-1]],p[stack[top]]) < q[i].slope )
                stack[top--]=0;
            else
                break;
        f[q[i].pos]=max(f[q[i].pos],q[i].A*p[stack[top]].first+q[i].B*p[stack[top]].second);
    }
    CDQ(mid+1,r);
    l1=l;l2=mid+1;
    for(i=l;i<=r;i++)
        if ( ( p[l1]<p[l2] || l2>r ) && l1<=mid )
            np[i]=p[l1++];
        else np[i]=p[l2++];
    memcpy( p+l , np+l , sizeof(p[0])*(r-l+1) );
}
int main()
{
    int i;
     
    //freopen("cash.in","r",stdin);
    //freopen("cash.out","w",stdout);
     
    cin>>n>>f[0];
    for(i=1;i<=n;i++)
    {
        scanf("%lf%lf%lf",&q[i].A,&q[i].B,&q[i].Rate);
        q[i].slope=-q[i].A/q[i].B;
        q[i].pos=i;
    }
    sort(q+1,q+n+1);
    CDQ(1,n);
    printf("%.3lf\n",f[n]);
}

最后还是来一句膜拜神犇吧 07年的第一题就这么难 这么难 这么难0.0.0.0.0.0.0.0.0.0
PoPoQQQ
关注
专栏目录
动态维护凸包
huyuncong的专栏
02-03 3697
依次插入n个点，询问凸包面积。 利用granham思想，维护凸包，水平序要维护两个凸壳，比较麻烦，所以用极角序，每次查入用平衡树维护极角离他最近的点，此时到双向链表上开始模拟granham双向删点，直到无法删为止，因为每个点至多删一次，所以是nlogn的复杂度。面积维护用叉积即时维护即可。 依次插入n个半平面，询问半平面交面积。 与上题类似，维护法向量的极角，双向删半平面（当相邻一半平面两交
CDQ分治（含例题：货币兑换、PARTIAL ORDER）
初学者
07-12 753
最近在整理原来的一些资料，偶然想起原来搞OI时讲过一次CDQ分治的内容，这里分享给大家 目录 预备知识 常见递归复杂度 分治思想 CDQ分治例题 货币兑换 PARTIAL ORDER 问题2D版本 问题3D版本 问题4D简化版本 问题4D版本 问题100D版本 总结 题目推荐 CDQ分治是一种特殊的分治方法，在OI界初见于陈丹琦2008年国家集训队作业中 预备知识 常见递归复杂度 先来分析下面这个递归方程： 其时间复杂度如何分析？ 将式子迭代两次得..
BZOJ2726任务安排 CDQ分治维护凸包
weixin_30323631的博客
08-16 114
好像不是很难，就是普通的CDQ分治，每次统计左边对右边的贡献 /* @Date : 2019-08-15 20:38:48 @Author : Adscn (adscn@qq.com) @Link : https://www.cnblogs.com/LLCSBlog */ #include<bits/stdc++.h> using namespace std; ...
平衡树维护动态凸包
weixin_30399055的博客
02-04 142
codeforces70D 有两种操作， 1 x y 将(x,y)加入当前的点集合中。 2 x y 询问(x,y)是否在当前点集形成的凸包内。 即我们要动态的维护凸包，将凸包分为上凸包和下凸包，然后将上凸包关于x轴对称一下， 那么只要维护两个下凸包。 考虑用平衡树（为了让x有序）来维护凸包，插入一个点时，判断是否在下凸包的下方，如果是则插入且不断往两边删点，直到所有的点都满足凸包...
1492: [NOI2007]货币兑换Cash
weixin_30699443的博客
04-23 139
Description 小Y最近在一家金券交易所工作。该金券交易所只发行交易两种金券：A纪念券（以下简称A券）和 B纪念券（以下 简称B券）。每个持有金券的顾客都有一个自己的帐户。金券的数目可以是一个实数。每天随着市场的起伏波动， 两种金券都有自己当时的价值，即每一单位金券当天可以兑换的人民币数目。我们记录第 K 天中 A券 和 B券 的 价值分别为 AK 和 BK（元/单位金券）。为...
bzoj2961 共点圆（cdq分治维护凸包，计算几何）
Icefox的博客
01-15 890
这题真是写的我有点绝望。菜不禁声。其实一开始是想拿KD tree树写的，听说能过，但是wa成狗？？至今改不对gg。一个点(x0,y0)在圆(x,y)内，要求 (x−x0)2+(y−y0)2<=x2+y2(x-x_0)^2+(y-y_0)^2<=x^2+y^2 化简一下就是 x20+y20<=2x0x+2y0yx_0^2+y_0^2<=2x_0x+2y_0y 假设y0>0y_0>0，我们有y>
【NOI2007】【BZOJ1492】货币兑换Cash
CreationAugust is 14 years old forever
04-09 1376
BZOJ题面是图片来的. 文字版题面 1797 货币兑换2007年NOI全国竞赛 时间限制: 1 s 空间限制: 128000 KB 题目等级 : 大师 Master题目描述 Description小 Y 最近在一家金券交易所工作。该金券交易所只发行交易两种金券：A 纪 念券（以下简称 A 券）和 B 纪念券（以下简称 B 券）。每个持有金券的顾客都有 一个自己的帐户。金券的数目可以
BZOJ 1176[Balkan2007]Mokia （cdq分治，矩阵加矩阵求和）
Dch19990825的博客
09-25 355
BZOJ 1176[Balkan2007]Mokia （cdq分治解三维偏序） Description 维护一个W*W的矩阵，初始值均为S.每次操作可以增加某格子的权值,或询问某子矩阵的总权值.修改操作数M<=160000,询问数Q<=10000,W<=2000000. Input 第一行两个整数,S,W;其中S为矩阵初始值;W为矩阵大小 接下来每行为一下三种输入之一(不包含引号...
[cdq分治习题练习]
MekakuCityActors的博客
08-20 540
bzoj1935 题意：给出n棵树的位置(xi,yi)，有m次询问，每次询问一个以(Xi,Yi)为左下角，(Li,Ri)为右上角的矩形内树的个数 题解：显然的三维偏序问题，一维是询问的时间T，一维是横坐标，一维是纵坐标。把初始的n棵树的位置当作插入，把询问当成4个二维前缀和相加减，由于时间是按照输入的顺序，所以第一维不需要排序，直接cdq分治处理第二维，树状数组维护第三维即可 /*********...
bzoj4311: 向量（线段树分治+凸包）
苟为蒟蒻又何妨
02-26 269
传送门 题意： 支持插入一个向量，删去某一个现有的向量，查询现有的所有向量与给出的一个向量的点积的最大值。 思路： 考虑线段树分治。 先对于每个向量处理出其有效时间放到线段树上面，然后考虑查询：对于两个已有的向量(u1,v1)(u_1,v_1)(u1​,v1​)和(u2,v2)(u_2,v_2)(u2​,v2​)，假设给出的向量为(x0,y0)(x_0,y_0)(x0​,y0​)u1&amp;g...
BZOJ2300[HAOI2011]防线修建——非旋转treap+凸包(平衡树动态维护凸包)
weixin_34417200的博客
04-23 114
题目描述 近来A国和B国的矛盾激化，为了预防不测，A国准备修建一条长长的防线，当然修建防线的话，肯定要把需要保护的城市修在防线内部了。可是A国上层现在还犹豫不决，到底该把哪些城市作为保护对象呢？又由于A国的经费有限，所以希望你能帮忙完成如下的一个任务： 1.给出你所有的A国城市坐标 2.A国上层经过讨论，考虑到经济问题，决定取消对i城市的保护，也就是说i城市不需要在防线内了 3....
bzoj 2726 [SDOI2012]任务安排 CDQ分治维护凸包 dp
make_it_for_good的博客
12-15 611
单调处理出第一个串往两边K个能覆盖的字符。 然后对四种字符每种字符做一遍FFT。 对于第一个串，如果这个位置不能匹配当前字符，那该位置为1。 对于第二个串，如果这个位置为当前字符，那该位置为1。 把第二个串反过来和第一个串跑FFT。 答案是在所有FFT中都为0的合法位置个数。#include <bits/stdc++.h> using namespace std; #define N 21
BZOJ 1492 货币兑换 cdq分治或平衡树维护凸包
weixin_34107739的博客
07-05 139
题意:链接 方法:cdq分治或平衡树维护凸包 解析: 这道题我拒绝写平衡树的题解，我仅仅想说splay不要写挂,insert边界条件不要忘。del点的时候不要脑抽d错。有想写平衡树的去看140142或者留言我。 首先这道题能推出个表达式 f[i]代表第i天最大收益。 xx[i]表示将第i天的钱都买A的数量 yy[i]表示将第i天的钱都买B的数量 ...
bzoj-1492 货币兑换Cash (1)——平衡树维护凸包
140142
07-11 1985
题意： 有n天和m的初始金钱，用来购买AB两种纪念券； n天里每天都有AB的价格，每天可以进行这样的操作； 1.卖出手中x%的纪念券(AB分别都卖出x%)； 2.用x的金钱买入纪念券，买入AB券的比例在第i天为Rate i； 求n天过去之后所获得的最大收益； 金钱和券数均为实数； n 题解： 首先，虽然题中的买入和卖出都是任意数量的，但是同样的纪念券，分几天卖出得到的收
【BZOJ1492】【NOI2007】—Cash（cdq分治维护凸包优化斜率dp）
weixin_30550081的博客
03-06 95
传送门 考虑令f[i]f[i]f[i]为第iii天得到的最多的AAA券，g[i]g[i]g[i]为第iii天得到的最多的BBB券 则g[i]=...
Bzoj2149拆迁队:cdq分治 凸包
weixin_30561177的博客
04-01 169
国际惯例的题面:我们考虑大力DP。首先重新定义代价为:1e13*选择数量-(总高度+总补偿)。这样我们只需要一个long long就能维护。然后重新定义高度为heighti - i，这样我们能选择高度相同的点，同时可以把无论如何也不会被选择的点扔掉(这样他们的高度<0)。之后就是转移，我们枚举i前面的被选择的点j，我们要满足的东西有:hj<=hi。考虑我们再次选择一个点会产生怎样的代价...
BZOJ 2300 HAOI2011 防线修建 平衡树维护凸包
世界
11-02 1994
题目大意：给定初始三个点(0,0)(n,0)和(x,y)，以及若干其它点，q次询问，每次删除一个点或求一次上凸包长度 平衡树维护凸包……和cash同样的思路为何我时隔2个月后的代码整整短了150行…… 平衡树最好用set 链表的每个点存set的迭代器 直接erase很方便 这个题x值的下限和上限都是给定的 所以没有边界讨论 真赞~ 一气呵成写出来 调了一小时 尼玛加点我居然加反了0.0
[BZOJ1492][NOI2007]货币兑换Cash（斜率优化dp+splay|cdq分治维护凸包）
薇小薇
01-11 367
题目： 我是超链接 题解： f[i]表示第i天最多能获得多少钱，那么f[0]=s 题目中有提示说要不全部买入要不全部卖出，其实比较好理解，因为能赚钱一定要尽量赚 首先考虑一个问题，如果某天赚到的钱知道了，能换成A券的数量a和能换成B券的数量b就确定了 a/b=rate[i] a*A[i]+b*B[i]=f[i]（A[i]，B[i]表示第i天两种金券的价值） 那就考虑已知f[1.
【BZOJ 2300】 [HAOI2011]防线修建 平衡树维护凸包
pbihao的博客
02-16 304
离线然后把所有的操作倒过来，这样就像星球大战一样，删点变成加点，动态用平衡树维护凸包就好了。 #include #include #include #include #include #define maxn 200021 using namespace std; struct P{ double x,y; P(double a=0,double b=0):x(a),y(b){} bool
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值