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;
}