[WF2011] MachineWorks（李超树优化dp）

最新推荐文章于 2022-07-10 10:57:30 发布

ikrvxt

最新推荐文章于 2022-07-10 10:57:30 发布

阅读量383

点赞数 1

分类专栏： # 普通/值域/势能/李超/可持久化线段树 DP 文章标签：动态规划算法图论李超树

本文链接：https://blog.csdn.net/Emm_Titan/article/details/121302241

版权

DP 同时被 2 个专栏收录

72 篇文章 3 订阅

订阅专栏

普通/值域/势能/李超/可持久化线段树

59 篇文章 5 订阅

订阅专栏

[WF2011]MachineWorks

problem

BZOJ3963

solution

来得比较快的是，直接设 $dp_{i,j}:$ 考虑第 $j$ 天换购 $i$ 机器。

但是马上注意到天数是 $1 e 9$ 级别的，而机器是 $1 e 5$ 级别。

稍微想想，就能知道，因为每天机器只能在那一天买，而为了最大化利益，肯定不可能买了一台机器在换购下一台机器前就卖了。

所以真正有用的只有 $n$ 天——离散化！！

因为机器过了那天就不能买了，所以将机器按照购买天数升序排序。

考虑 $dp_i:$ 当前以 $i$ 机器执行转型期的已知利润最大值。

有两种情况：

case1：就是前面一台机器都没买，用最开始的钱购买这一台机器开始赚钱，比较简单。
case2：考虑在换购这一台机器前是用的机器 $j$ 。

则有转移： $dp_i=\max\Big\{dp_j+G_j\Big(D_i-D_j-1\Big)+R_j-P_i\Big\}$

整理一下得到， $dp_i=\max\Big\{-G_j·D_i+dp_j-G_j(D_j+1)+R_j\Big\}-P_i$

然后要用 $dp_i$ 去更新最后的答案， $dp_i$ 是已知的利润，最后的答案就是假设这个机器不再改变。

即 $ans=max\Big\{dp_i+(T-D_i)G(i)+R(i)\Big\}$ 。

当然要满足前面赚的钱 / 最开始的钱能够买得起这件机器，再更新，否则会出错。

比如这台机器赚的利润非常高，结果买不起，答案可能会被这台压根买不了的机器利润更新成最大值。

$dp_i$ 的转移式子简直不能太熟悉了！

因为 $G$ 不具有单调性，所以不能斜率优化。

~~就算能，李超树不香吗？？只要不会超时，宁可死也要用李超不用斜率优化。~~

将 $G_j$ 当成 $k$ ， $dp_j-G_j(D_j+1)+R_j$ 当成 $b$ ，每次以 $D_i$ 查。

code

#include <bits/stdc++.h>
using namespace std;
#define maxn 100005
#define int long long
int n, C, T;
int d[maxn], f[maxn];
struct Node { int D, P, R, G; }v[maxn];
struct node { int k, b; }t[maxn << 2];

#define lson now << 1
#define rson now << 1 | 1
#define mid ( ( l + r ) >> 1 )

int calc( node l, int x ) { return l.k * d[x] + l.b; }

bool cover( node Old, node New, int x ) {
    return calc( Old, x ) <= calc( New, x );
}

void insert( int now, int l, int r, node New ) {
    if( cover( t[now], New, l ) and cover( t[now], New, r ) ) {
        t[now] = New;
        return;
    }
    if( l == r ) return;
    if( cover( t[now], New, mid ) ) swap( t[now], New );
    if( cover( t[now], New, l ) ) insert( lson, l, mid, New );
    if( cover( t[now], New, r ) ) insert( rson, mid + 1, r, New );
}

int query( int now, int l, int r, int x ) {
    if( ! t[now].k and ! t[now].b ) return 0;
    if( l == r ) return calc( t[now], x );
    int ans;
    if( x <= mid ) ans = query( lson, l, mid, x );
    else ans = query( rson, mid + 1, r, x );
    return max( ans, calc( t[now], x ) );
}

signed main() {
    int Case = 0;
    while( scanf( "%lld %lld %lld", &n, &C, &T ) ) {
        if( ! n and ! C and ! T ) break;
        memset( t, 0, sizeof( t ) );
        memset( f, 0, sizeof( f ) );
        int ans = C;
        for( int i = 1, D, P, R, G;i <= n;i ++ ) {
            scanf( "%lld %lld %lld %lld", &D, &P, &R, &G );
            v[i] = { D, P, R, G };
            d[i] = D;
        }
        sort( d + 1, d + n + 1 );
        sort( v + 1, v + n + 1, []( Node x, Node y ) { return x.D < y.D; } );
        int m = unique( d + 1, d + n + 1 ) - d - 1;
        for( int i = 1;i <= n;i ++ ) v[i].D = lower_bound( d + 1, d + m + 1, v[i].D ) - d;
        for( int i = 1;i <= n;i ++ ) {
            int x = max( query( 1, 1, m, v[i].D ), C );
            if( x >= v[i].P ) {
                f[i] = x - v[i].P + v[i].R;
                ans = max( ans, f[i] + v[i].G * ( T - d[v[i].D] ) );
                insert( 1, 1, m, { v[i].G, f[i] - ( d[v[i].D] + 1 ) * v[i].G } );
            }
        }
        printf( "Case %lld: %lld\n", ++ Case, ans );
    }
    return 0;
}