NOI 2007 货币兑换Cash （cdq分治 or Splay）

最新推荐文章于 2018-07-29 17:32:51 发布
最新推荐文章于 2018-07-29 17:32:51 发布
阅读量870 收藏
点赞数
文章标签： 分治 Splay
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csuhoward/article/details/47172349
版权

在cdq分治之前，先用n^2的算法理一理题意。

Description

Input

第一行两个正整数N、S，分别表示小Y 能预知的天数以及初始时拥有的钱数。 接下来N 行，第K 行三个实数AK、BK、RateK，意义如题目中所述

Output

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

Sample Input

3 100
1 1 1
1 2 2
2 2 3

Sample Output

225.000

HINT

测试数据设计使得精度误差不会超过10-7。
对于40%的测试数据，满足N ≤ 10；
对于60%的测试数据，满足N ≤ 1 000；
对于100%的测试数据，满足N ≤ 100 000；


题解

此题见cdq论文

其他博客：http://www.cppblog.com/zxytim/archive/2010/04/28/113854.html

只要记录第i天的最大价值为f[i]：

f[i] = max{f[i - 1], value(j, i) = (在第j天买光f[j]的钱,在第i天卖完所得的价值)}
在第j天卖光可以得到股票B的数量 nb = f[j] / (A[j] * Rate[j] + B[j])
在第j天卖光可以得到股票A的数量 na = nb * Rate[j]
所以value(j, i) = na * A[i] + nb * B[i];
复杂度O(n^2)，60分。代码长度 < 1kb


cdq的论文中是用f[i]记录第i天a股的个数，意思相同：

f [1]←S * Rate[1] / (A[1] * Rate[1] + B[1]) 

Ans←S

For i ← 2 to n

  For j ← 1 to i-1

    x ← f [j] * A[i] + f [j] / Rate[j] * B[i]

    If x > Ans

      Then Ans ← x

  End For

  f [i] ← Ans * Rate[i] / (A[i] * Rate[i] + B[i])

End For

Print(Ans)




Splay 强行维护一个凸包 可以过掉 由于Splay维护一个凸包 所以每次插入一个点都再处理一下这个点的左右是否仍然保持凸性，删除凸包内的点，也可能该点在凸包内就一次删掉了。（加了读入优化，可忽略）

图稍微盗几张放这里吧，凸性的一些证明详细这个链接， http://www.cppblog.com/zxytim/archive/2010/04/28/113854.html ，我是模仿这位菊苣的写的，由于抄的不留心导致debug了很久。

盗图部分，外链就是上面那条：


/*
观察可以发现，可以成为最大值的点一定是所有点在一象限以x递增，y递减的一些点构成的凸壳


取得最大时：

所以我们要维护这个凸壳上的点。

插入时的维护：
 




对一条斜率已知的直线查询时：
因为凸壳上斜率递减，所以可以通过对某个点与左右的点所构成直线的斜率进行判断：






具体维护的时候为了达到较好的复杂度，要用平衡树维护。我选择了Splay，因为有些操作在Splay上面要方便些。。

*/

不懂伸展树进这里看，《算法合集之《伸展树的基本操作与应用》http://wenku.baidu.com/link?url=JznzcqFPVexmkM82og5ya1ui77gOyM105ETjqAp6V0tcUG8f08Tmc5D2DD2CUUmcuNwV3UZUtRv5idMwClHmhFI4ZaRzcEZtnzNQapOMyfe

代码这样：

/***********************************/

    #include <iostream>
    #include <cstdio>
    #include <cstring>
    #include <algorithm>
    #include <cmath>
    const int maxn = 100010;

    #define REP(i,n) for(int i=0;i<n;i++)
    #define FOR(i,l,r) for(int i=l;i<=r;i++)
    #define INF 1e10
    #define eps 1e-8

    typedef double DB;

    using namespace std;

    /** I/O Accelerator Interface .. **/ //{
    #define g (c=getchar())
    #define d isdigit(g)
    #define p x=x*10+c-'0'
    #define n x=x*10+'0'-c
    #define pp l/=10,p
    #define nn l/=10,n
    template<class T> inline T& RD(T &x){
        char c;while(!d);x=c-'0';while(d)p;
        return x;
    }

    inline DB& RF(DB &x){
        //scanf("%lf", &x);
        char c;while(g,c!='-'&&c!='.'&&!isdigit(c));
        if(c=='-')if(g=='.'){x=0;DB l=1;while(d)nn;x*=l;}
            else{x='0'-c;while(d)n;if(c=='.'){DB l=1;while(d)nn;x*=l;}}
        else if(c=='.'){x=0;DB l=1;while(d)pp;x*=l;}
            else{x=c-'0';while(d)p;if(c=='.'){DB l=1;while(d)pp;x*=l;}}
        return x;
    }
    #undef nn
    #undef pp
    #undef n
    #undef p
    #undef d
    #undef g


    template<class T> inline void OT(const T &x){
        printf("%.3lf\n", x);
    }


    template<class T> inline void checkMax(T &a,const T b){if (a<b) a=b;}




    struct SplayNode{
        int l, r, fa;
        double x, y;
    }node[maxn];
    int tot=0;

    inline double CrossProduct(double x0, double y0, double x1, double y1, double x2, double y2){
        return (x1 - x0) * (y2 - y0) - (y1 - y0) * (x2 - x0);
    }
    inline double CrossProduct(int a, int b, int c){
        return CrossProduct(node[a].x, node[a].y,
            node[b].x, node[b].y,
            node[c].x, node[c].y);
    }

    namespace SplayTree{

        int root = 0;

        inline void RightRotate(int x){
            int l = node[x].l, fa = node[x].fa;

            node[x].l = node[l].r; node[node[x].l].fa = x;
            node[l].r = x; node[x].fa = l;

            if (fa){
                if (x == node[fa].l){
                    node[fa].l = l;
                }
                else{
                    node[fa].r = l;
                }
            }
            node[l].fa = fa;
        }

        inline void LeftRotate(int x){
            int r = node[x].r, fa = node[x].fa;

            node[x].r = node[r].l; node[node[x].r].fa = x;
            node[r].l = x; node[x].fa = r;

            if (fa){
                if (x == node[fa].l){
                    node[fa].l = r;
                }
                else{
                    node[fa].r = r;
                }
            }
            node[r].fa = fa;
        }

        inline void Splay(int x, int FA){
            int fa, Fa;
            while(node[x].fa != FA){
                fa = node[x].fa;
                Fa = node[fa].fa;
                if (Fa == FA){
                    if (x == node[fa].l)
                        RightRotate(fa);
                    else
                        LeftRotate(fa);
                }
                else{
                    if (x == node[fa].l){
                        if (fa == node[Fa].l){
                            RightRotate(Fa);
                            RightRotate(fa);
                        }
                        else{
                            RightRotate(fa);
                            LeftRotate(Fa);
                        }
                    }
                    else{
                        if (fa == node[Fa].r){
                            LeftRotate(Fa);
                            LeftRotate(fa);
                        }
                        else{
                            LeftRotate(fa);
                            RightRotate(Fa);
                        }
                    }
                }
            }
            if (FA == 0)
                root = x;
        }

        inline int Pred(int x){
            if (node[x].l){
                x = node[x].l;
                while(1){
                    if (!node[x].r){
                        return x;
                    }
                    x = node[x].r;
                }
            }
            else{
                while(1){
                    if (node[x].fa){
                        if (x == node[node[x].fa].r){
                            return node[x].fa;
                        }
                        x = node[x].fa;
                    }
                    else{
                        return 0;
                    }
                }
            }
        }

        inline int Succ(int x){
            if (node[x].r){
                x = node[x].r;
                while(1){
                    if (!node[x].l){
                        return x;
                    }
                    x = node[x].l;
                }
            }
            else{
                while(1){
                    if (node[x].fa){
                        if (x == node[node[x].fa].l){
                            return node[x].fa;
                        }
                        x = node[x].fa;
                    }
                    else{
                        return 0;
                    }
                }
            }
        }

        inline void Del(int now){
            Splay(now, 0);

            int pred = Pred(now), succ = Succ(now);
            if (pred && succ){
                Splay(pred, 0);
                Splay(succ, root);
                node[node[root].r].l = 0;
            }
            else if (pred && !succ){
                Splay(pred, 0);
                node[root].r = 0;
            }
            else if (!pred && succ){
                Splay(succ, 0);
                node[root].l = 0;
            }
            else{
                root = 0;
            }

        }

        inline void AdjustLeft(int now){
            int p1, p2;
            while(1){
                p1 = Pred(now);
                p2 = Pred(p1);
                if (p1 && p2){
                    if(CrossProduct(p2, p1, now) >= 0 || node[p1].y <= node[now].y){
                        Del(p1);
                    }
                    else{
                        break;
                    }
                }
                else if(p1 && node[p1].y <= node[now].y){
                    Del(p1);
                }
                else{
                    break;
                }
            }
        }

        inline void AdjustRight(int now){
            int p1, p2;
            while(1){
                p1 = Succ(now);
                p2 = Succ(p1);
                if (p1 && p2){
                    if(CrossProduct(now, p1, p2) >= 0){
                        Del(p1);
                    }
                    else{
                        break;
                    }
                }
                else{
                    break;
                }
            }
        }

        inline void Adjust(int now){
            int pred = Pred(now); int succ = Succ(now);
            if (pred && succ && CrossProduct(pred, now, succ) >= 0){
                Del(now);
            }
            else if (succ && node[succ].y >= node[now].y){
                Del(now);
            }
            else{
                AdjustLeft(now);
                AdjustRight(now);
            }
        }

        inline void Insert(double x, double y){
            int now = root, fa = 0, flag = 0;
            while(1){
                if (!now){
                    now = ++tot;
                    node[now].x = x, node[now].y = y;
                    node[now].fa = fa;
                    if (flag == 0){
                        node[fa].l = now;
                    }
                    else{
                        node[fa].r = now;
                    }
                    Splay(now, 0);
                    break;
                }
                else{
                    fa = now;
                    if (x <= node[now].x) now = node[now].l, flag = 0;
                    else now = node[now].r, flag = 1;
                }
            }
            Adjust(root);
        }

        inline double Cal(double x, double y, double A, double B){
            return A*x + B*y;
        }

        inline double Slope(double x, double y){
            if (fabs(x) < eps){
                return INF;
            }
            return y/x;
        }

        inline double getMax(double A, double B){
            double k = -A/B;
            double x, y;
            int now = root;
            while(1){
                x = node[now].x; y = node[now].y;
                int pred = Pred(now), succ = Succ(now);
                if (!pred && !succ){
                    return Cal(x, y, A, B);
                }
                else if (pred && !succ){
                    if (k <= Slope(x - node[pred].x, y - node[pred].y)){
                        return Cal(x, y, A, B);
                    }
                    else{
                        if (node[now].l){
                            now = node[now].l;
                        }
                        else{
                            return Cal(x, y, A, B);
                        }
                    }
                }
                else if (!pred && succ){
                    if (k >= Slope(node[succ].x - x, node[succ].y - y)){
                        return Cal(x, y, A, B);
                    }
                    else{
                        if (node[now].r){
                            now = node[now].r;
                        }
                        else{
                            return Cal(x, y, A, B);
                        }
                    }
                }
                else{
                    double kl = Slope(x - node[pred].x, y - node[pred].y);
                    double kr = Slope(node[succ].x - x, node[succ].y - y);
                    if (kl >= k && k >= kr){
                        return Cal(x, y, A, B);
                    }
                    else if(k <= kr){
                        now = node[now].r;
                    }
                    else{
                        now = node[now].l;
                    }
                }
            }
        }

    }

    int main(){
//        freopen("data.in","r",stdin);
//        freopen("data.out","w",stdout);

        int n, s;
        double ans, A, B, R;

        RD(n); RD(s);

        RF(A); RF(B); RF(R);
        ans = s;

        #define y (ans/(A*R+B))
        #define x (y*R)

        SplayTree::Insert(x,y);
        FOR(i,2,n){

            RF(A); RF(B); RF(R);
            checkMax(ans, SplayTree::getMax(A, B));

            SplayTree::Insert(x, y);


            #undef x
            #undef y
        }


        OT(ans);

        return 0;
    }








下面进入cdq分治

/********************************/


csuhoward
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
noi2007测试数据
09-13
【标题】"noi2007测试数据"所指的是全国青少年信息学奥林匹克竞赛（NOI）2007年的比赛测试数据集。这是一场针对中学生的信息学竞赛，旨在提升他们的计算机编程和算法设计能力。测试数据是比赛的重要组成部分，用于...
1492: [NOI2007]货币兑换Cash
weixin_30699443的博客
04-23 136
Description 小Y最近在一家金券交易所工作。该金券交易所只发行交易两种金券：A纪念券（以下简称A券）和 B纪念券（以下 简称B券）。每个持有金券的顾客都有一个自己的帐户。金券的数目可以是一个实数。每天随着市场的起伏波动， 两种金券都有自己当时的价值，即每一单位金券当天可以兑换的人民币数目。我们记录第 K 天中 A券 和 B券 的 价值分别为 AK 和 BK（元/单位金券）。为...
[NOI2007]货币兑换Cash
feiliboos
12-03 176
/* 写完以后发现有牛人使用STL……在BZOJ(开了O2)上可以AC…… http://hi.baidu.com/wwwaaannngggrs/blog/item/e536b809c5b533d23bc763ca.html */ 这道题是非常典型的斜率优化，蛋疼之处在于x并不单调，得用Splay维护…… 方程是f[i]=max(f[i-1],a[i]*x[j]+b[i]*y...
bzoj 1492: [NOI2007]货币兑换Cash
lqybzx的专栏
04-13 1032
Description Input 第一行两个正整数N、S，分别表示小Y 能预知的天数以及初始时拥有的钱数。 接下来N 行，第K 行三个实数AK、BK、RateK，意义如题目中所述 Output 只有一个实数MaxProfit，表示第N 天的操作结束时能够获得的最大的金钱 数目。答案保留3 位小数。 Sample Input 3 100 1 1 1 1 2 2
bzoj 1492: [NOI2007]货币兑换Cash （dp+cdq分治）
clover_hxy的博客
09-09 1244
1492: [NOI2007]货币兑换Cash Time Limit: 5 Sec  Memory Limit: 64 MB Submit: 3801  Solved: 1602 [Submit][Status][Discuss] Description 小Y最近在一家金券交易所工作。该金券交易所只发行交易两种金券：A纪念券（以下简称A券）和 B纪念券（以下 简称B券）。每个持有金
[NOI 2007]货币兑换Cash
weixin_30521649的博客
03-21 67
Description 题库链接 （按我的语文水平完全无 fa♂ 概括题意，找了 hahalidaxin 的题意简述... 有 \(AB\) 两种货币，每天可以可以付 \(IP_i\) 元，买到 \(A\) 券和 \(B\) 券，且 \(A:B=Rate_i\) ，也可以卖掉 \(OP_i\%\) 的 \(A\) 券和 \(B\) 券，每天 \(AB\) 价值为 \(A_i\) 和 \(B_i\)...
NOI导刊-贪心与分治.ppt
11-14
×××NOI导刊--贪心与分治××× ···算法--贪心、分治··· ···如有错误，望私信纠正···
NOI WC 2007 试题
09-25
### 重要知识点解析 #### 一、重复子串问题 **问题背景与定义：** - **定义：** 如果一个字符串 `v` 在另一个字符串 `u` 中出现，则称 `v` 是 `u` 的子串；若 `vv` （即 `v` 与自身的连接）是 `u` 的子串，则称 `...
noi c++-2007 线性
最新发布
04-07
c++--2007 线性
NOI2007货币兑换CASH 斜率DP
ACMer不要报考高校代码为13627的移通学院！
08-01 651
做到一道题，不会做。 题解说是FFT+ CDQ分治。 学会了FFT，发现不会CDQ分治。 去看CDQ的论文，发现用了CASH这道题…… 然后貌似有斜率DP的东西，就顺便学了斜率DP，写了之前HDU的一道题，继续写这道题…… 各种题解各种SPLAY，我一想，这道题用map就行了啊……然后写了200多行，还超级慢…… 最囧的问题，在我和朋友的电脑上，用NOI的数据AC，在
[BZOJ1492][NOI2007]货币兑换Cash
srand(time(0))
02-06 494
动态规划优化 斜率优化 splay
【BZOJ4943】【UOJ315】【NOI2017】蚯蚓
cz_xuyixuan的博客
05-30 381
【题目链接】BZOJUOJ【思路要点】先说做法：用链表模拟蚯蚓的队列。对于每一个1号操作，计算所有新增的，长度在50以内的子串的哈希值，并加入哈希表中。对于每一个2号操作，计算所有被切断的，长度在50以内的子串的哈希值，并在哈希表中除去。对于每一个3号操作，计算每个子串的哈希值，并在哈希表中找到它们的出现次数，并相乘得到答案。显然，2号操作的总复杂度为\(O(CK^2)\)，3号操作的总复杂度为\...
bsoj 2238 【NOI2007】货币兑换 (DP+斜率优化+splay维护)
志当存高远
10-11 1852
【NOI2007】货币兑换 Time Limit:10000MS  Memory Limit:65536K Total Submit:193 Accepted:50  Case Time Limit:1000MS Description 　　　  　　　 Input 　　　 Output 　　　 Sample Input 　　　 Sample
洛谷-4027 【NOI2007】 货币兑换
Light.NKOI
02-08 311
题目描述 小 Y 最近在一家金券交易所工作。该金券交易所只发行交易两种金券：A 纪念券（以下简称 A 券）和 B 纪念券（以下简称 B 券）。每个持有金券的顾客都有一个自己的帐户。金券的数目可以是一个实数。 每天随着市场的起伏波动，两种金券都有自己当时的价值，即每一单位金券当天可以兑换的人民币数目。我们记录第 K 天中 A 券和 B 券的价值分别为 AKA_KAK​ 和BKB_KBK​ （元/...
1492: [NOI2007]货币兑换Cash DP+斜率优化+splay维护凸包/CDQ分治
ws_fqk
02-29 903
似乎两个月之前我写过一次这题写挂了？ 《多年的心头大恨终于解决了系列》 我们可以发现，存在最优解满足每次将全部的钱买了券或每次将全部的券卖成钱，因为有利益我们要尽可能的去获得，有亏损就一点也不要碰。 我们用fif_i表示到ii天时的最大收益，令xi,yix_i,y_i分别表示第ii天购买AA券和BB券的数量。则如果将第ii天的收益全部买成券，那么满足 fi=Ai∗xi+Bi∗yif_i=A_
【NOI2007】货币兑换
时光真疯狂, 我一路执迷于匆忙.
08-16 1376
今天听了crazy和samjia的NOI杂（砸）题选讲，感觉自己萌萌哒~ 于是就来怡情地写了这道题。Description额(⊙o⊙)…，这个不好说啊。（语文不好不好裱我） 还是贴图吧。 n<=10^5Solution咳咳，希望大家都看懂题了。 一个很明显的贪心思路就是，我们每天要不全买，要不全卖。 因为一有利益我们就去占，一有亏损我们就不碰。 那么我们可以有dp方程：F[i]=
【CDQ分治】NOI2007货币兑换Cash
氧化钠的博客
07-29 322
分析： 非常经典的CDQ版题。。。不知道为什么之前没写博客。。现在补上。 首先，不难得到一个会T的DP，定义DP[i]DP[i]DP[i]表示前i天能得到的最大钱数。 DP[i]=max{DP[j]∗Ai+DP[j]/ratej∗Bi}DP[i]=max{DP[j]∗Ai+DP[j]/ratej∗Bi}DP[i]=max\{DP[j]*A_i+DP[j]/rate_j*B_i\} 即表示在...
dp四边形优化 Hdu 2829 Lawrence 题解
Monica
05-19 1029
累加器传送门：http://blog.csdn.net/NOIAu/article/details/71775000题目传送门：https://cn.vjudge.net/problem/HDU-2829这道题我在这篇博客上写过斜率优化的题解:http://blog.csdn.net/NOIAu/article/details/72369084这里我就不对dp转移进行讲解，由于cost满足凸性和包含
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值