HDU2829 Lawrence(斜率优化dp)

学了模板题之后上网搜下斜率优化dp的题目，然后就看到这道题，知道是斜率dp之后有思路就可以自己做不出来，要是不事先知道的话那就说不定了。

题意：给你n个数，一开始n个数相邻的数之间是被东西连着的，对于连着的一片的数，它们的价值就是两两乘积的和。所以4 5 1 2一开始就是4*5+4*1+4*2+5*1+5*2+1*2... 注意到两两乘积的和其实是可以这么算的((a1+a2+a3+..an)^2-(a1^2+a2^2+....))/2。现在我可以在数与数之间切m刀，问切完之后的最小价值是多少。

一个自然的想法是定义dp[n][t]表示的是前n个数被切了t刀的最小价值，不难发现方程是可以这么转移的

dp[i][t]=dp[j][t-1]+((sum[i]-sum[j])*(sum[i]-sum[j])-(d[i]-d[j]))/2  (j<i) 其中d[i]表示前i个数的平方的和

所以这个方程是1个三维的dp，对于1000的数据量是行不通的，所以仿照斜率优化的思路，我们可以尝试写出当 k<j时，j比k更优的方程，即:

dp[j][t-1]+((sum[i]-sum[j])*(sum[i]-sum[j])-(d[i]-d[j]))/2 < dp[k][t-1]+((sum[i]-sum[k])*(sum[i]-sum[k])-(d[i]-d[k]))/2

经过化简，我们可以得到一个这样的东西：

(2dp[j]+sum[j]^2+d[j])-(2dp[k]+sum[k]^2+d[k])/2*(sum[j]-sum[k])  <  sum[i]

显然又是一个斜率式子，利用先前推导的性质我们可以知道，我们每次更新的时候其实就是利用t-1层的信息推出t层的信息，推的时候实际有效的值也是一个下凸的点集，这个和上一题不一样之处就在于要更新m次，每次队列都要重新入队，但总体来说还是一样的，由于斜率优化后里层的dp达到线性，所以最后复杂度出来是O(n^2)的，仍然要注意之所以一开始可以弹队首是因为 sum[i]是递增的。

#pragma warning(disable:4996)

#include <iostream>

#include <cstdio>

#include <vector>

#include <algorithm>

#include <cstring>

#include <string>

#include <cmath>

using namespace std;



#define ll long long

#define maxn 1100



ll dp[maxn][maxn];

ll a[maxn];

ll sum[maxn];

ll d[maxn];



int n, m;



ll getup(int i, int j, int t){

	return (2 * dp[i][t] + sum[i] * sum[i] + d[i]) - (2 * dp[j][t] + sum[j] * sum[j] + d[j]);

}



ll getdown(int i, int j){

	return 2 * (sum[i] - sum[j]);

}



int que[maxn];

int qh, qt;



int main()

{

	while (cin >> n >> m&&(n||m)){

		a[0] = d[0] = sum[0] = 0;

		for (int i = 1; i <= n; ++i){

			scanf("%I64d", &a[i]);

			sum[i] = sum[i - 1] + a[i];

			d[i] = d[i - 1] + a[i] * a[i];

		}

		dp[0][0] = 0;

		for (int i = 1; i <= n; ++i){

			dp[i][0] = dp[i - 1][0] + a[i] * sum[i - 1];

		}

		for (int x = 1; x <= m; ++x){

			dp[0][x] = 0;

			qh = qt = 0;

			que[qt++] = 0;

			for (int i = 1; i <= n; ++i){

				while (qh + 1 < qt && getup(que[qh + 1], que[qh], x - 1) <= sum[i] * getdown(que[qh + 1], que[qh])){

					qh++;

				}

				dp[i][x] = dp[que[qh]][x - 1] + ((sum[i] - sum[que[qh]])*(sum[i] - sum[que[qh]]) - (d[i] - d[que[qh]])) / 2;

				while (qh + 1 < qt && getup(i, que[qt - 1], x - 1)*getdown(que[qt - 1], que[qt - 2]) <= getup(que[qt - 1], que[qt - 2], x - 1)*getdown(i, que[qt - 1])){

					qt--;

				}

				que[qt++] = i;

			}

		}

		printf("%I64d\n", dp[n][m]);

	}

	return 0;

}