BZOJ3675 [APIO2014]序列分割（斜率优化模板）

Address

• BZOJ3675 洛谷P3648

---

Solution

• 仿佛终于懂一点斜率优化了
• 设 $f[i][r]$ 表示第 $r$ 次分割到第 $i$ 个位置的最大化得分，$sum[i]$ 表示 $\sum \limits_{j = 1}^i a[j]$。
• 分割的顺序和得分无关，转移显然为： $$f[i][r] = \max\{f[j][r - 1] + (sum[i] - sum[j]) \times sum[j], 0 \le j < i\}$$

• 假设位置 $k$ 比位置 $j(j > k)$ 相对于 $i$ 更优，则（先忽略第二维 $r$）：
  

  $$\begin{align} f[k] + (sum[i] - sum[k]) \times sum[k] &> f[j] + (sum[i] - sum[j]) \times sum[j]\\ f[k] + sum[i] \times sum[k] - sum[k] ^ 2 &> f[j] + sum[i] \times sum[j] - sum[j] ^ 2\\ (f[k] - sum[k] ^ 2) - (f[j] - sum[j] ^ 2) &> sum[i] \times (sum[j] - sum[k])\\ \frac{(f[k] - sum[k] ^ 2) - (f[j] - sum[j] ^ 2)}{sum[j] - sum[k]} &> sum[i]\\ \end{align}$$

• 我们记 $G(k, j) = \frac{(f[k] - sum[k] ^ 2) - (f[j] - sum[j] ^ 2)}{sum[j] - sum[k]}$。

• 考虑若存在一个选取位置的子序列 $q_1, q_2, ... , q_m(1 \le q_1 < q_2 < ... < q_m \le n)$，满足 $sum[i] < G(q_1, q_2) < G(q_2, q_3) < ... < G(q_{m - 1}, q_m)$。
• 则 $q_1$ 比 $q_2$ 优，$q_2$ 比 $q_3$ 优，…，$q_{m - 1}$ 比 $q_m$ 优，即 $q_1$ 是这个子序列中的最优解。
• 这样，我们就可以用一个 $G$ 递增的单调队列来维护，保证每次从队首取出的都是最优解。
• 考虑怎样维护这个单调队列。
• 记单调队列 $q$ 的队首为 $head$，队尾为 $tail$。
• 因为 $sum[i]$ 递增，若 $G(q[head], q[head + 1]) < sum[i]$，弹出 $q[head]$。
• 进一步的，我们把 $(-sum[k], f[k] - sum[k] ^ 2)$ 和 $(-sum[j], f[j] - sum[j] ^ 2)$ 看做平面直角坐标系上的两个点，则 $G(j, k)$ 即为两点所在直线的斜率，这也是这种优化被叫做斜率优化的原因。
• 那么 $G$ 递增转化成图形大概就长这样：
  
• 这不就是下凸壳吗？
• 既然是凸壳，自然要有凸壳的性质。
• 回忆维护凸壳的过程，我们可以得到在插入位置 $i$ 的维护过程：
  
  • 若 $G(q[tail - 1], q[tail]) > G(q[tail], i)$，则弹出 $q[tail]$（可以自己画下图，如果不弹出它，凸壳就不凸了）
• 时间复杂度 $O(nK)$。

Code

//原题应该还要输方案，记录下最优转移的位置往回跳即可。
#include <iostream>
#include <cstdio>
#include <cctype>
#include <algorithm>
#include <cstring>

using namespace std;

typedef long long ll;

namespace inout
{
    const int S = 1 << 20;
    char frd[S], *ihed = frd + S;
    const char *ital = ihed;

    inline char inChar()
    {
        if (ihed == ital)
            fread(frd, 1, S, stdin), ihed = frd;
        return *ihed++;
    }

    inline int get()
    {
        char ch; int res = 0; bool flag = false;
        while (!isdigit(ch = inChar()) && ch != '-');
        (ch == '-' ? flag = true : res = ch ^ 48);
        while (isdigit(ch = inChar()))
            res = res * 10 + ch - 48;
        return flag ? -res : res;
    }

    char fwt[S], *ohed = fwt;
    const char *otal = ohed + S;

    inline void outChar(char ch)
    {
        if (ohed == otal)   
            fwrite(fwt, 1, S, stdout), ohed = fwt;
        *ohed++ = ch;
    }

    inline void put(int x)
    {
        if (x > 9) put(x / 10);
        outChar(x % 10 + 48);
    }   
};
using namespace inout;
const int N = 1e5 + 5, K = 205;
ll f[N][2]; int h[N], sum[N], g[N][K], n, k;
//洛谷卡空间，f数组滚动。

inline ll Sqr(ll x)
{
    return x * x;
}

inline double Slope(int j, int a, int b)
{
    if (sum[a] == sum[b]) return -1e18;
    return (double)(f[b][j] - Sqr(sum[b]) - f[a][j] + Sqr(sum[a]))
         / (double)(sum[a] - sum[b]); 
}

int main()
{

    n = get(); k = get();
    for (int i = 1; i <= n; ++i) 
        sum[i] = sum[i - 1] + get();
    for (int j = 1; j <= k; ++j)
    {
        int t = 0, w = 0,
            now = j & 1, lst = j - 1 & 1; 
        for (int i = 1; i <= n; ++i)
        {
            while (t < w && Slope(lst, h[t], h[t + 1]) <= sum[i]) ++t;
            f[i][now] = f[h[t]][lst] + (ll)(sum[i] - sum[h[t]]) * sum[h[t]];
            g[i][j] = h[t];
            while (t < w && Slope(lst, h[w - 1], h[w]) >= Slope(lst, h[w], i)) --w;
            h[++w] = i;
        }
    }

    cout << f[n][k & 1] << endl; 
    for (int i = k, x = n; i; --i)
        put(x = g[x][i]), outChar(' ');
    fwrite(fwt, 1, ohed - fwt, stdout);

    return 0; 
}