题意：
有n天和m的初始金钱，用来购买AB两种纪念券；
n天里每天都有AB的价格，每天可以进行这样的操作；
1.卖出手中x%的纪念券(AB分别都卖出x%)；
2.用x的金钱买入纪念券，买入AB券的比例在第i天为Rate i；
求n天过去之后所获得的最大收益；
金钱和券数均为实数；
n<=100 000；
题解：
首先，虽然题中的买入和卖出都是任意数量的，但是同样的纪念券，分几天卖出得到的收 益，一定小于等于直接在一天卖出的收益；
同样，分几天买入也是不如一天花所有钱买入的；
令：
显然X,Y都可以由f[i]得来；f[i]为第i天的最大收益；
X[i]为第i天将所有钱数都买入得到的A券数；
Y[i]为第i天将所有钱数都买入得到的B券数；
那么转移方程就是：
f[i]=max(f[i-1]，A[i] * X[j] + B[i] * Y[j])；(1<=j< i)；
这样转移是O(n^2)的，所以要对后面枚举j的部分优化；
将f[i]=A[i] * X[j] + B[i] * Y[j]整理；
得到Y[i]=(-A[i]/B[i]) * X[i] + f[i]/B[i]；
这是一个直线方程的形式，而对于固定的i，直线斜率不变，而要最大化截距；
倘若将所有的[1,i-1]的点计算出(x,y)放在坐标系上；
找到最优值相当于在这个上凸包上找到某个点，使截距最大；
那么这个点左面的斜率一定大于当前i的斜率，右面的斜率一定小于当前i的斜率；
所以这其实就是一个斜率优化的形式；
但是这个-A[i]/B[i]不单调，所以不能O(n)的维护队列处理凸包；通常我们做斜率优化都是找到不符合要求的点直接干掉就好的；
因为下一个i的斜率不是递增就是递减；
10^5的复杂度是支持O(nlogn)的，所以为了维护凸包可以选择一些数据结构；
那么就维护一个Splay，每个结点都在凸包上，中序遍历就是按x递增同时也按斜率递减的序列；
如果把Splay看做logn，那么每个点最多进出凸包一次，二分查询斜率共n次；
复杂度O(nlogn)还是听起来很好的；
但是写起来一点也不好玩！
总之维护凸包时对Splay中点较少时的讨论很烦。。。
照着对拍调数据改改也就过了；
代码3k+，时间960ms，这个跑的感觉也是挺快的了；
下一篇写写更神的CDQ分治，毕竟数据结构对代码能力要求颇高；
代码：
#include<math.h>
#include<stdio.h>
#include<string.h>
#include<algorithm>
#define N 110000
#define which(x) (tr[tr[x].fa].ch[1]==x)
const double INF = 1e100;
const double EPS = 1e-8;
using namespace std;
struct Point
{
double x, y, s1, s2;
int fa, ch[2];
}tr[N];
int root, tot;
double f[N], A[N], B[N], R[N], X[N], Y[N];
void get_shope(int a, int b)
{
if (!a) tr[b].s1 = INF;
else if (!b) tr[a].s2 = -INF;
else
{
if (fabs(tr[a].x - tr[b].x)<EPS)
tr[a].s2 = tr[b].s1 = (tr[a].y<tr[b].y ? INF : -INF);
else
tr[a].s2 = tr[b].s1 = (tr[a].y - tr[b].y) / (tr[a].x - tr[b].x);
}
}
void Rotate(int x)
{
int f = tr[x].fa;
if (!f) return;
bool k = which(x);
tr[f].ch[k] = tr[x].ch[!k];
tr[x].ch[!k] = f;
tr[tr[f].fa].ch[which(f)] = x;
tr[x].fa = tr[f].fa;
tr[tr[f].ch[k]].fa = f;
tr[f].fa = x;
}
void Splay(int x, int g)
{
if (!x) return;
while (tr[x].fa != g)
{
int f = tr[x].fa;
if (tr[f].fa == g)
{
Rotate(x);
break;
}
if (which(x) ^ which(f))
Rotate(x);
else
Rotate(f);
Rotate(x);
}
if (!g) root = x;
}
int Pre(int x)
{
if (!x) return 0;
int p = tr[x].ch[0];
if (!p) return 0;
while (tr[p].ch[1])
p = tr[p].ch[1];
return p;
}
int Sub(int x)
{
if (!x) return 0;
int p = tr[x].ch[1];
if (!p) return 0;
while (tr[p].ch[0])
p = tr[p].ch[0];
return p;
}
int find(int p, double x)
{
if (!p) return 0;
if (x<tr[p].x)
return find(tr[p].ch[0], x);
else
{
int t = find(tr[p].ch[1], x);
return tr[p].x>tr[t].x ? p : t;
}
}
void Insert(double X, double Y, int no)
{
int x = find(root, X), y = 0;
if (!x)
{
x = root;
while (tr[x].ch[0])
x = tr[x].ch[0];
Splay(x, 0);
y = x, x = 0;
}
else
{
Splay(x, 0);
Splay(y = Sub(x), x);
}
tr[no].x = X, tr[no].y = Y;
if (y) tr[no].fa = y, tr[y].ch[0] = no;
else tr[no].fa = x, tr[x].ch[1] = no;
get_shope(x, no);
get_shope(no, y);
if (tr[no].s1 <= tr[no].s2)
{
tr[y].ch[0] = 0;
get_shope(x, y);
return;
}
Rotate(no), Rotate(no);
root = no;
x = tr[no].ch[0];
while (tr[x].s1 <= tr[x].s2&&x)
{
y = Pre(x);
Splay(y, x);
tr[y].fa = no;
tr[no].ch[0] = y;
get_shope(y, no);
x = y;
}
x = tr[no].ch[1];
while (tr[x].s1 <= tr[x].s2&&x)
{
y = Sub(x);
Splay(y, x);
tr[y].fa = no;
tr[no].ch[1] = y;
get_shope(no, y);
x = y;
}
}
int query(double S)
{
int p = root;
while (S>tr[p].s1 || S<tr[p].s2)
{
if (S>tr[p].s1) p = tr[p].ch[0];
else p = tr[p].ch[1];
}
return p;
}
int main()
{
int n, i, j, k;
scanf("%d%lf", &n, &f[1]);
for (i = 1; i <= n; i++)
scanf("%lf%lf%lf", A + i, B + i, R + i);
tr[0].x = tr[0].y = -INF;
Y[1] = f[1] / (A[1] * R[1] + B[1]);
X[1] = R[1] * Y[1];
Insert(X[1], Y[1], 1);
for (i = 2; i <= n; i++)
{
j = query(-A[i] / B[i]);
f[i] = max(f[i - 1], A[i] * X[j] + B[i] * Y[j]);
Y[i] = f[i] / (A[i] * R[i] + B[i]);
X[i] = R[i] * Y[i];
Insert(X[i], Y[i], i);
}
printf("%.3lf", f[n]);
return 0;
}
bzoj-1492 货币兑换Cash (1)——平衡树维护凸包
原文地址：http://blog.csdn.net/ww140142/article/details/46839437
