hdu 2829 Lawrence

Problem

acm.hdu.edu.cn/showproblem.php?pid=2829

vjudge.net/contest/76380#problem/B

Reference

blog.csdn.net/ahfywff/article/details/7922605

Meaning

一条铁路上有 n 个仓库，每个仓库有个值 Si[i]。同过铁路连接成连通块，如果两个仓库中间的铁路被炸了，则被炸铁路两侧的仓库不再属于同一连通块。

属于同一连通块的一段仓库 [ L , R ] 有一个战略价值：Sv = Si[L] * sum( L+1 , R ) + Si[L+1] * sum( L+2 , R ) + … + Si[R-1] * sum( R , R)。

一个仓库独自成一个连通块，则该连通块的 Sv 值为 0。

现在有 m 个炸弹，每个炸弹能炸一段铁路，问能得到的这一整段仓库的最小的 Sv 值。

Analysis

定义状态：dp[j][i]：将前 i 个仓库分成 j 段得到的最小 Sv 值。

状态转移：dp[j][i] = min { dp[j-1][k] + pre[i] - pre[k] - ( sum[i] - sum[k] ) * sum[k] }

其中，sum[k] = Si[1] + Si[2] + … + Si[k]，即 Si 的前缀和。

pre[k] = Si[1] * sum( 2 , k ) + Si[2] * sum ( 3 , k ) + … + Si[k-1] * sum( k , k)，即前 k 个仓库属于同一连通块是的 Sv 值。
然后就可以斜率优化。

要注意单调队列第一个进队的值，不一定是 0，而应该是当前枚举的 i 的初始值的前一个（见代码注释）

新姿势：(a % 2 == 0) <=> (a & 1 ^ 1) <=> (~ a & 1)

Code

#include <cstdio>
using namespace std;
const int N = 1000;

int pre[N+1], sum[N+1], dp[2][N+1], que[N];

inline int up(int l, int f, int g)
{
	return dp[~g&1][l] - pre[l] + sum[l] * sum[l] -
		dp[~g&1][f] + pre[f] - sum[f] * sum[f];
}

inline int down(int l, int f)
{
	return sum[l] - sum[f];
}

int main()
{
	int n, m;
	pre[0] = sum[0] = 0;
	while(scanf("%d%d", &n, &m), n||m)
	{
		for(int i=1, in; i<=n; ++i)
		{
			scanf("%d", &in);
			sum[i] = sum[i-1] + in;
			pre[i] = pre[i-1] + in * sum[i-1];
		}
		for(int i=0; i<=n; ++i)
			dp[1][i] = pre[i];
		for(int g=2; g<=m+1; ++g)
		{
			int h = 0, t = 0;
			/* 第一个进队的元素不是0 */
			que[t++] = g - 1;
			/* i从g开始枚举，故第一个进队的应是g-1 */
			for(int i=g; i<=n; ++i)
			{
				while(h+1 < t && up(que[h+1], que[h], g) <
						sum[i] * down(que[h+1], que[h]))
					++h;
				dp[g&1][i] = dp[~g&1][que[h]] + pre[i] - pre[que[h]] -
					(sum[i] - sum[que[h]]) * sum[que[h]];
				while(h+1 < t &&
						up(i, que[t-1], g) * down(que[t-1], que[t-2]) <
						up(que[t-1], que[t-2], g) * down(i, que[t-1]) )
					--t;
				que[t++] = i;
			}
		}
		printf("%d\n", dp[m+1&1][n]);
	}
	return 0;
}