[NOI2007]货币兑换

Description

小Y最近在一家金券交易所工作。该金券交易所只发行交易两种金券：A纪念券（以下简称A券）和 B纪念券（以下
简称B券）。每个持有金券的顾客都有一个自己的帐户。金券的数目可以是一个实数。每天随着市场的起伏波动，
两种金券都有自己当时的价值，即每一单位金券当天可以兑换的人民币数目。我们记录第 K 天中 A券 和 B券 的
价值分别为 AK 和 BK（元/单位金券）。为了方便顾客，金券交易所提供了一种非常方便的交易方式：比例交易法
。比例交易法分为两个方面：（a）卖出金券：顾客提供一个 [0,100] 内的实数 OP 作为卖出比例，其意义为：将
OP% 的 A券和 OP% 的 B券 以当时的价值兑换为人民币；（b）买入金券：顾客支付 IP 元人民币，交易所将会兑
换给用户总价值为 IP 的金券，并且，满足提供给顾客的A券和B券的比例在第 K 天恰好为 RateK；例如，假定接
下来 3 天内的 Ak、Bk、RateK 的变化分别为：

假定在第一天时，用户手中有 100元 人民币但是没有任何金券。用户可以执行以下的操作：

注意到，同一天内可以进行多次操作。小Y是一个很有经济头脑的员工，通过较长时间的运作和行情测算，他已经
知道了未来N天内的A券和B券的价值以及Rate。他还希望能够计算出来，如果开始时拥有S元钱，那么N天后最多能
够获得多少元钱。
Input
输入第一行两个正整数N、S，分别表示小Y能预知的天数以及初始时拥有的钱数。接下来N行，第K行三个实数AK、B
K、RateK，意义如题目中所述。对于100%的测试数据，满足：0<AK≤10；0<BK≤10；0<RateK≤100；MaxProfit≤1
0^9。

【提示】

1.输入文件可能很大，请采用快速的读入方式。
2.必然存在一种最优的买卖方案满足：
每次买进操作使用完所有的人民币；
每次卖出操作卖出所有的金券。

Output

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

Sample Input

3 100
1 1 1
1 2 2
2 2 3

Sample Output

225.000

---

不是这题为啥那么恶心为啥还要拿个数据结构来维护凸包然后还那么难调浪费了我半天的时间还去网上抄的题解

这道题一开始没看见提示然后还推了半天暴力DP

设x[i] ， y[i]表示第i天最多能买多少A劵,B劵

f[i]表示第i天的最大收益

然后DP式子肥肠明显

(x[i] = frac{Rate[j] * f[j]}{Rate[j]*A[j] + B[j]})

(y[i] = frac{f[j]}{Rate[j] * A[j] + B[j]})

(f[i] = A[i] * x[j] + B[i] * y[j])

然后60pts就到手了

化简个式子

就可以得到$-frac{A[i] * x[j]}{B[i]} + frac{f[i]}{B[i]} = y[j] $

那么是不是(k = -frac{A[i]}{B[i]} , x = x[j] , b = frac{f[i]}{B[i]} , y = y[j])

答案都在一个凸包上

那这样是不是就可以斜率优化了？？

所以我就肥肠眼瞎的用单调队列写了一发 ， 开心的得到了20pts

然而 x[j] 并不单调==

因为每天能买到的A劵的上限不是单调递增的

所以我眼瞎

我们可以考虑用一个数据结构来维护

可以用平衡树或者CDQ来维护这个凸包

但是由于平衡树维护凸包难 不会 写

所以使用CDQ维护凸包

考虑每一天的X只能对这一天及以后的天产生影响

所以我们先对k排序（因为要保证斜率单调下降）

然后我们使用CDQ分治的时候就用左边一半来更新右边一半的答案

最后再把左右两边按照x单增排序

这样就可以解决x不单调的问题了

#include<cmath>
#include<cstdio>
#include<cstring>
#include<algorithm>
const double INF = 1e18 ;
const int M = 100005 ;
const double eps = 1e-8 ;
using namespace std ;
int n , top , st[M] ;
double f[M] ;
struct Node {
	double A , B , Rate , X , Y , k ; int Id ;
}p[M] , t[M] ;
inline double X(int i) { return p[i].X ; }
inline double Y(int i) { return p[i].Y ; }
inline double Slope(int i , int j) {
	if(fabs(X(i) - X(j)) <= eps) return INF ;
	return (Y(i) - Y(j)) / (X(i) - X(j)) ; 
}
inline bool operator < (Node a , Node b) { return a.k > b.k ; }
inline void Solve(int l , int r) {
	if(l == 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].Rate * p[l].Y ;
		return ;
	}
	int mid = (l + r)>>1 ;
	int tl = l , tr = mid + 1 ;
	for(int i = l ; i <= r ; i ++)
	  if(p[i].Id <= mid) t[tl++] = p[i] ;
	  else t[tr++] = p[i] ;
	for(int i = l ; i <= r ; i ++) p[i] = t[i] ;
	Solve(l , mid) ; 
	int tail = 0 ;
	for(int i = l ; i <= mid ; i ++) {
		while(tail > 1 && Slope(st[tail - 1] , st[tail]) <= Slope(st[tail - 1] , i)) --tail ;
		st[++tail] = i ;
	}
	int head = 1 ;
    for(int i = mid + 1 ; i <= r ; i ++) {
    	while(head < tail && Slope(st[head] , st[head + 1]) >= p[i].k) ++head ;
    	int j = st[head] ;
    	f[p[i].Id] = max(f[p[i].Id] , p[j].X * p[i].A + p[j].Y * p[i].B) ;
	}
	Solve(mid + 1 , r) ;
	tl = l , tr = mid + 1 ;
	for(int i = l ; i <= r ; i ++)
	  if(( (p[tl].X < p[tr].X) || (fabs(p[tl].X - p[tr].X) < eps && p[tl].Y < p[tr].Y) || tr > r ) && tl <= mid ) t[i] = p[tl++] ;
	  else t[i] = p[tr++] ;
	for(int i = l ; i <= r ; i ++) p[i] = t[i] ;
}
int main() {
	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].Id = i ; p[i].k = -p[i].A / p[i].B ;
	}
	sort(p + 1 , p + n + 1) ;
	Solve(1 , n) ;
	printf("%lf
",f[n]) ;
	return 0 ;
}