BZOJ3675 Apio2014 序列分割 【斜率优化】

Description

小H最近迷上了一个分隔序列的游戏。在这个游戏里，小H需要将一个长度为n的非负整数序列分割成k+1个非空的子序列。为了得到k+1个子序列，小H需要重复k次以下的步骤：

1.小H首先选择一个长度超过1的序列（一开始小H只有一个长度为n的序列——也就是一开始得到的整个序列）；

2.选择一个位置，并通过这个位置将这个序列分割成连续的两个非空的新序列。

每次进行上述步骤之后，小H将会得到一定的分数。这个分数为两个新序列中元素和的乘积。小H希望选择一种最佳的分割方式，使得k轮之后，小H的总得分最大。

Input

输入第一行包含两个整数n，k（k+1≤n）。

第二行包含n个非负整数a1，a2，...，an（0≤ai≤10^4），表示一开始小H得到的序列。

Output

输出第一行包含一个整数，为小H可以得到的最大分数。

Sample Input

7 3

4 1 3 4 0 2 3

Sample Output

108

HINT

【样例说明】

在样例中，小H可以通过如下3轮操作得到108分：

1．-开始小H有一个序列(4，1，3，4，0，2，3)。小H选择在第1个数之后的位置将序列分成两部分，并得到4×(1+3+4+0+2+3)=52分。

2．这一轮开始时小H有两个序列：(4)，(1，3，4，0，2，3)。小H选择在第3个数字之后的位置将第二个序列分成两部分，并得到(1+3)×(4+0+2+ 3)=36分。

3．这一轮开始时小H有三个序列：(4)，(1，3)，(4，0，2，3)。小H选择在第5个数字之后的位置将第三个序列分成两部分，并得到(4+0)×(2+3)= 20分。

经过上述三轮操作，小H将会得到四个子序列：(4)，(1，3)，(4，0)，(2，3)并总共得到52+36+20=108分。

【数据规模与评分】

：数据满足2≤n≤100000,1≤k≤min(n -1，200)。

思路

发现其实划分的顺序并不重要

最后的贡献就是所有块两两和的乘积的和

所以可以直接从前到后进行划分

划分\(k+1\)次，每次划分一个前缀

然后就可以发现有一个很显然的转移

\(dp_{i,k} = max(dp_{j,k-1} + sum_{j}*(sum_{i}-sum_{j}))\)

拆开之后就变成

\(dp_{i,k} = max(dp_{j,k-1} - sum_{j}^2 + sum_{i}*sum_{j})\)

就变成挺显然的斜率式子了

把转移用平面上的点表示，维护上凸壳

然后直接用向量的求法就可以了

---

//Author: dream_maker
#include<bits/stdc++.h>
using namespace std;
//----------------------------------------------
//typename
typedef long long ll;
//convenient for
#define for_up(a, b, c) for (int a = b; a <= c; ++a)
#define for_down(a, b, c) for (int a = b; a >= c; --a)
#define for_vector(a, b) for (int a = 0; a < (signed)b.size(); ++a)
//inf of different typename
const int INF_of_int = 1e9;
const ll INF_of_ll = 1e18;
//fast read and write
template <typename T>
void Read(T &x){
  bool w = 1;x = 0;
  char c = getchar();
  while(!isdigit(c) && c != '-')c = getchar();
  if(c == '-')w = 0, c = getchar();
  while(isdigit(c)) {
    x = (x<<1) + (x<<3) + c -'0';
    c = getchar();
  }
  if(!w)x=-x;
}
template <typename T>
void Write(T x){
  if(x < 0) {
    putchar('-');
    x=-x;
  }
  if(x > 9)Write(x / 10);
  putchar(x % 10 + '0');
}
//----------------------------------------------
const int N = 1e5 + 10;
const int K = 2e2 + 10;
struct Node{
  ll x, y;
  Node (ll x = 0, ll y = 0):x(x), y(y) {}
}p[2][N];
Node operator - (const Node &a, const Node &b) {
  return Node(a.x - b.x, a.y - b.y);
}
ll operator * (const Node &a, const Node &b) {
  return a.x * b.y - a.y * b.x;
}
int q[N];
int n, k;
ll s[N];
ll cal(Node las, int now) {
  return las.y + s[now] * las.x;
}
int main() {
  Read(n), Read(k);
  for_up(i, 1, n) {
    Read(s[i]);
    s[i] += s[i-1];
  }
  int ind = 0;
  for_up(i, 1, n) p[ind][i] = Node(s[i], -s[i] * s[i]);
  for_up(j, 2, k + 1) {
    ind ^= 1;
    int l = 1, r = 1;
    q[1] = j - 1;
    for_up(i, j, n) {
      while (l < r && cal(p[ind ^ 1][q[l]], i) <= cal(p[ind ^ 1][q[l + 1]], i)) l++;
      p[ind][i] = Node(s[i], cal(p[ind ^ 1][q[l]], i) - s[i] * s[i]);
      while (l < r && (p[ind ^ 1][i] - p[ind ^ 1][q[r]]) * (p[ind ^ 1][i] - p[ind ^ 1][q[r - 1]]) <= 0) r--;
      q[++r] = i;
    }
  }
  Write(p[ind][n].y + s[n] * s[n]);
  return 0;
}