【BZOJ】【CodeForces】【DP】【带权二分】5331/321E 贞鱼/Ceil and Gondolas

BZOJ 5331 贞鱼 & CodeForces 321E Ceil and Gondolas

题目大意

有$N$个人，将他们分成$K$段，每段中的每两个人之间会产生一个怨气值，要求最小化怨气值之和。

分析

先考虑一个普通的 DP ：设状态$f(i,j)$表示将前$i$条贞鱼分为$j$组的最小怨气值，$s(i,j)$为怨气值的二维前缀和，那么我们可以列出状态转移方程：$f(i,j)=\min\{f(k,j-1)+w(i,k)\}$

其中$w(i,j)$为将区间$[i,j]$中的贞鱼分到一起的代价，不难得到$w(i,j)=\frac{s(i,i)+s(j,j)-s(i,j)\times2}{2}$

显然复杂度过不去，那么考虑优化：

我们发现对于两个决策点$k_1,k_2$，设$k_1<k_2$，在某个时候若$k_2$比$k_1$更优，那么一定满足：
$f(k_2,j-1)+\frac{s(i,i)+s(k_2,k_2)-2s(i,k_2)}{2}<f(k_1,j-1)+\frac{s(i,i)+s(k_1,k_1)-2s(i,k_1)}{2}$

整理一下得到：
$f(k_2,j-1)-f(k_1,j-1)<s(i,k_2)-s(i,k_1)+\frac{s(k_1,k_1)-s(k_2,k_2)}{2}$

我们发现右边一定是单调递增的，然而由于这东西和$i$有关，在替换掉决策点之后，这东西就不一定单增了。。。

于是我们就考虑用一个单调队列来维护这个东西。

我们发现对于一个决策点，它会成为一个区间的最优决策点，所以我们就用队列保存一个决策点和它对应的左右端点即可。

在插入一个决策点时，我们将所有不可能被用于转移的点弹出队列，然后取出队列里的最后一个节点，将它裂成两个区间，用二分找出它的最优分割点，再将后一半区间的决策点设为$i$并加入队列。

但这样的复杂度仍需$O(NK\log N)$的，仍然不够。

我们 通过打表 发现$K$值越大，答案越大，也就是说，答案是一个关于$K$的有凸性的函数，故可以用带权二分将时间优化至$O(N\log K\log N)$。

参考代码

MD 这题 BZOJ 和 CF 上都卡读入优化。。。

所以有个读入优化的板子很重要

#include <cstdio>
#include <algorithm>
using namespace std;

const int Maxn = 4000;

struct QNode {
	int l, r, pos;
	QNode(){}
	QNode(int lef, int rig, int p) {
		l = lef, r = rig, pos = p;
	}
};

int N, K;
int A[Maxn + 5][Maxn + 5];
int sum[Maxn + 5][Maxn + 5];

int f[Maxn + 5], g[Maxn + 5];
int calc_cost(int i, int j) {
	return f[j] + (sum[j][j] + sum[i][i] - sum[i][j] - sum[j][i]) / 2;
}
QNode q[Maxn + 5];
int head, tail;
int find(QNode p, int pos) {
	int l = p.l, r = p.r, ret;
	while(l <= r) {
		int mid = (l + r) / 2;
		if(calc_cost(mid, pos) > calc_cost(mid, p.pos))
			l = mid + 1, ret = mid;
		else r = mid - 1;
	}
	return ret;
}
bool check(int val) {
	q[head = tail = 0] = QNode(1, N, 0);
	f[0] = 0, g[0] = 0;
	for(int i = 1; i <= N; i++) {
		while(head <= tail && q[head].r < i) head++;
		q[head].l = i;
		f[i] = calc_cost(i, q[head].pos) + val;
		g[i] = g[q[head].pos] + 1;
		if(head > tail || calc_cost(N, i) <= calc_cost(N, q[tail].pos)) {
			while(head <= tail &&
				calc_cost(q[tail].l, i) <= calc_cost(q[tail].l, q[tail].pos))
					tail--;
			if(head > tail) q[++tail] = QNode(1, N, i);
			else {
				int pos = find(q[tail], i);
				q[tail].r = pos;
				q[++tail] = QNode(pos + 1, N, i);
			}
		}
	}
	return g[N] < K;
}

#define gc if(++ip == ie) fread(ip = buf, 1, SZ, stdin)
const int SZ = 1 << 19;
char buf[SZ], *ie = buf + SZ, *ip = ie - 1;
inline int read() {
	gc;
	while(*ip < '-') gc;
	bool f = (*ip == ' ');
	if(f) gc;
	int x = *ip & 15; gc;
	while(*ip > '-') {
		x *= 10;
		x += (*ip & 15);
		gc;
	}
	return f ? -x : x;
}//抄的 TLY 大神的 QAQ...

int main() {
#ifdef LOACL
	freopen("in.txt", "r", stdin);
	freopen("out.txt", "w", stdout);
#endif
	N = read(), K = read();
	for(int i = 1; i <= N; i++)
		for(int j = 1; j <= N; j++)
			A[i][j] = read();
	for(int i = 1; i <= N; i++)
		for(int j = 1; j <= N; j++)
			sum[i][j] = sum[i - 1][j] + sum[i][j - 1]
						- sum[i - 1][j - 1] + A[i][j];
	int lb = 0, ub = 1e9;
	int ans;
	while(lb <= ub) {
		int mid = (lb + ub) / 2;
		if(check(mid)) ub = mid - 1;
		else lb = mid + 1, ans = f[N] - K * mid;
	}
	printf("%d\n", ans);
	return 0;
}