BZOJ3963: [WF2011]MachineWorks

Description

你是任意性复杂机器公司(Arbitrarily Complex Machines, ACM)的经理，公司使用更加先进的机械设备生产先进的机器。原来的那一台生产机器已经坏了，所以你要去为公司买一台新的生产机器。你的任务是在转型期内尽可能得到更大的收益。在这段时间内，你要买卖机器，并且当机器被ACM公司拥有的时候，操控这些机器以获取利润。因为空间的限制，ACM公司在任何时候都只能最多拥有一台机器。
在转型期内，有若干台可能卖出的机器。作为先进机器的专家，对于每台机器Mi，你已经知道了其价格Pi和可以买入的日期Di。注意，如果不在第Di天买入机器Mi，那么别的人也会买走这一台机器，也就是说，以后你将没有机会购买这台机器了。如果ACM的钱低于一台机器的价格，那么你显然不可能买到这一台机器。
如果你在第Di天买入了机器Mi,那么ACM公司可以从第(Di)+1天开始使用这一台机器。每使用这台机器一天，就可以为公司创造出Gi美元的收益。
你可以决定要在买入之后的某一天，以一定的折扣价卖出这一台机器。收购市场对于每一台机器，都有一个折扣价Ri。你不能在卖出的那一天使用机器，但是你可以在卖出的那一天再买入一台新的。
在转型期结束后，ACM公司会卖掉当前所拥有的机器。你的任务就是最大化转型期间ACM公司可以得到的收入。

Input

输入包含若干组测试用例。每一组测试用例的第一行有3个正整数N，C和D。N是将会卖出的机器的台数(N<=105)(N<=10^5)(N<=105)，C是在转型期开始时公司拥有的美元数量(C<=109)(C<=10^9)(C<=109)，D是转型期持续的天数(D<=109)(D<=10^9)(D<=109)。
之后的N行每一行描述了一台机器的情况。每一行有4个正整数Di,Pi,Ri和Gi,分别表示这台机器卖出的时间，购买这台机器需要的美元数量，卖出这台机器的折扣价和使用这台机器可以得到的利润。这些数字满足1<=Di<=D,1<=Ri<Pi<=1091<=Di<=D,1<=Ri<Pi<=10^91<=Di<=D,1<=Ri<Pi<=109且1<=Gi<=1091<=Gi<=10^91<=Gi<=109.
最后一组测试用例后面的一行由3个0组成，表示输入数据。

Output

对于每一组测试用例，输出测试用例的编号，之后给出ACM公司在第D+1天结束后可以得到的最大数量的美元。
请依照下面给出的样例输出。

Sample Input

6 10 20
6 12 1 3
1 9 1 2
3 2 1 2
8 20 5 4
4 11 7 4
2 10 9 1
0 0 0

Sample Output

Case 1: 44

比较裸的CDQ+斜率优化吧

直接维护就行了？雾

首先定义一下DP:dpidp_idpi表示卖完第i台机器的最大收益，也就是卖出上一台机器的收益-pip_ipi

然后考虑转移dpi=max(dpj+rj+(di−dj−1)∗dj)−pidp_i=max(dp_j+r_j+(d_i-d_j-1)*d_j)-p_idpi=max(dpj+rj+(di−dj−1)∗dj)−pi
把中间展开dpi=dpj+rj−(dj+1)∗gj+di∗gj−pidp_i=dp_j+r_j-(d_j+1)*g_j+d_i*g_j-p_idpi=dpj+rj−(dj+1)∗gj+di∗gj−pi
然后变成点斜式dpi+pi−di∗gj=dpj+dj−(dj+1)∗gjdp_i+p_i-d_i*g_j=dp_j+d_j-(d_j+1)*g_jdpi+pi−di∗gj=dpj+dj−(dj+1)∗gj
然后我们只需要判断一下可不可行dpi>pidp_i>p_idpi>pi然后直接CDQ分治，用左边的维护凸包，然后将右边的斜率排一下序直接查找就好了

不想写归并所以就直接sort了，多个log影响不大

 #include<bits/stdc++.h>

 using namespace std;

 #define LL long long

 #define pi pair<LL,LL>

 #define N 100010

 #define INFF 1e16

 #define INFI 0x3f3f3f3f3f3f3f3f

 LL n,m,c;

 LL dp[N];//买入机器i之后的最大收益

 struct Machine{

     LL d,p,r,g;

     void init(){scanf("%lld%lld%lld%lld",&d,&p,&r,&g);}

 }t[N];

 struct Node{

     LL x,y;

     Node(){}

     Node(int id){

         x=t[id].g;

         y=dp[id]+t[id].r-t[id].g*(t[id].d+);

     }

     Node(LL _x,LL _y){x=_x,y=_y;}

 };

 vector<Node> lq,rq;

 deque<Node> q;

 bool cmpMachine(Machine a,Machine b){return a.d<b.d;}

 bool cmpNode(Node a,Node b){

     if(a.x==b.x)return a.y<b.y;

     return a.x<b.x;

 }

 double getk(Node a,Node b){

     if(a.x==b.x)return INFF;

     return (double) (a.y-b.y)/(double) (a.x-b.x);

 }

 void solve(int l,int r){

     if(l==r){

         dp[l]=max(dp[l],1ll*c);dp[l]-=t[l].p;

         if(dp[l]<)dp[l]=-INFI;

         return;

     }

     int mid=(l+r)>>;

     solve(l,mid);

     lq.clear();rq.clear();q.clear();

     for(int i=l;i<=mid;i++)if(dp[i]!=-INFI)lq.push_back(Node(i));

     for(int i=mid+;i<=r;i++)rq.push_back(Node(t[i].d,i));

     sort(lq.begin(),lq.end(),cmpNode);

     sort(rq.begin(),rq.end(),cmpNode);

     for(int i=;i<lq.size();i++){

         while(q.size()>=&&getk(lq[i],q.back())>getk(q.back(),q[q.size()-]))q.pop_back();

         q.push_back(lq[i]);

     }

     if(q.size()){

         for(int i=;i<rq.size();i++){

             while(q.size()>=&&getk(q[],q[])>-rq[i].x)q.pop_front();

             dp[rq[i].y]=max(dp[rq[i].y],q.front().x*rq[i].x+q.front().y);

         }

     }

     solve(mid+,r);

 }

 int main(){

     int T=;

     while(scanf("%lld%lld%lld",&m,&c,&n)&&(n||m||c)){

         for(int i=;i<=m;i++)t[i].init(),dp[i]=-INFI;

         t[++m]=(Machine){n+,,,};dp[m]=-INFI;

         sort(t+,t+m+,cmpMachine);

         solve(,m);

         printf("Case %d: %lld\n",++T,dp[m]);

     }

     return ;

 }