洛谷P1848 书架

好，我一直以为书架是splay，然后发现还有个优化DP的书架。妃的书架

蓝书和PPT上面都讲了，应该比较经典吧。

题意：

有n个物品，每个都有宽，高。

把它们分成若干段，使得每段的最大值的总和最小。且每段的总宽度不超过L。

n <= 100000

解：

首先有个很显然的DP是f[i] = min(f[j] + max(j + 1, i)), sum[i] - sum[j] <= L

然后如何优化呢？因为有max函数(非线性)所以难以单调队列。把决策打出来发现不单调。无计可施？？？

发现当i固定的时候，max(j + 1, i)是一段一段单减的。这样相当于能确定状态转移方程中的后者。

再看前者，f[j]这个东西，其实是单调不减的。证明：把f[j - 1]按照f[j]的方式划分即可<=f[j]。

怎么利用呢？朴素的想法是把每一个数前面最大的数用单调栈求出来，记为to[]数组。

那么每次转移的时候跳to[]即可。可以发现在区间(to[i], i)之间的转移都不优于to[i]。

这里忽视了一个小问题，有个宽度限制在这里。我的解决办法是用pos记录最早的一个能够转移过来的位置。pos的维护显然是线性的。

这个好想好写的东西最坏复杂度还是n²，递增序列就能卡掉，然而交上去有90分......

来考虑正解。我们能不能每次不跳to[]链，而是更快的求出最小值来转移呢？

很容易(困难)想到用堆维护。对于失效的转移用延迟删除法。

问题就只剩如何判断转移失效了。

如果转移的j < pos，显然不行。此外，如果j不在以i开头的to链上，也是不行的。

有个朴素的想法是用数组维护是否在to链上，即每次把i前面比i小的舍去，但是又会被递增卡成n²。

仔细思考，发现以i开头的to链就是单调栈在处理到i时的栈内元素。

于是我们一边DP一边维护单调栈，只需判断j是在否在栈中即可。

至此，时间复杂度优化为nlogn，可以通过此题。

记得开long long

#include <cstdio>
#include <algorithm>
#include <queue>
#define mp std::make_pair

typedef long long LL;
const int N = 100010;

LL f[N], sum[N];
int st[N][25], pow[N], n, to[N], p[N], top;
bool in_stk[N];
std::priority_queue<std::pair<LL, int> > Q;

inline void STinit() {
    int j = 1, lm = 0;
    while((1 << lm) <= n) {
        while(j < (1 << (lm + 1)) && j <= n) {
            pow[j] = lm;
            j++;
        }
        lm++;
    }
    for(int j = 1; j < lm; j++) {
        for(int i = 1; i + (1 << j) - 1 <= n; i++) {
            st[i][j] = std::max(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
        }
    }
    return;
}

inline int getmax(int l, int r) {
    int t = pow[r - l + 1];
    return std::max(st[l][t], st[r - (1 << t) + 1][t]);
}

int main() {
    int L;
    scanf("%d%d", &n, &L);
    for(int i = 1; i <= n; i++) {
        scanf("%d%lld", &st[i][0], &sum[i]);
        sum[i] += sum[i - 1];
        f[i] = 1ll << 60;
    }

    STinit();
    st[0][0] = 0x7f7f7f7f;
    to[0] = -1;

    int pos = 0;
    for(int i = 1; i <= n; i++) {
        while(st[i][0] >= st[p[top]][0]) {
            in_stk[p[top]] = 0;
            top--;
        }
        to[i] = p[top];
        p[++top] = i;
        in_stk[i] = 1;

        Q.push(mp(-1 * (f[to[i]] + getmax(to[i] + 1, i)), i));


        while(sum[i] - sum[pos] > L) {
            pos++;
        }
        while((!Q.empty()) && (to[Q.top().second] < pos || (!in_stk[Q.top().second]))) {
            Q.pop();
        }
        if(!Q.empty()) {
            f[i] = -1 * Q.top().first;
        }
        f[i] = std::min(f[i], f[pos] + getmax(pos + 1, i));
    }
    /*for(int i = 1; i <= n; i++) {
        printf("%lld ", f[i]);
    }*/
    printf("%lld", f[n]);
    return 0;
}

但是还有很多可以改进的地方。

比如to这个数组可否舍去？ST表可否舍去？我是懒得优化了T_T