【CodeForces】【单调队列优化DP】939F Cutlet

CodeForces 939F Cutlet

题目大意

有一块牛排需要两面都需要煎 $N$ 秒，现仅有 $K$ 个时间段 $[L_i,R_i]$ 可以用来翻面，这段时间内可以任意翻转这块牛排。

问最少翻多少次使得牛排两面都煎了 $N$ 秒。

分析

神奇的 DP。

定义状态 $f(i,j)$ 为在前 $i$ 个时间段中，当前朝上的那一面已经被烤了 $j$ 秒钟的最小翻转次数。

那么不难列出状态转移方程：

• 当我们不翻转时：$f(i,j)=f(i-1,j)$；
• 当我们翻转一次时： $f(i,j)=f(i-1,i-j)+1$，这个转移仅当在区间 $[L_i,R_i]$ 内发生。

显然这个转移是 $O(N^{2}K)$ 的。我们必须考虑优化

---

结论： 当我们在一个区间内最多翻转两次牛排。

证明： 当我们在一个区间里翻转三次及以上的牛排时，我们可以发现仅隔一段的两段时间所煎的牛排的面是相同的，于是我们可以通过等价的交换区间来减少牛排翻面的次数。

注意我们翻转两次牛排是为了仅让另一面煎一段时间，而出来时仍然是开始时的那一面。可以证明这种操作是有必要的。

---

当我们仅翻转一次时，设翻转后两面煎的时间相差 $k$ ，翻转的时刻为 $j$ ，可以得到翻转后朝上的那一面的煎的时间为 $R_i-j$ ，朝下的那一面的煎的时间就是 $R_i-j-k$。

由于翻过来后两面是互换了的，所以有 f ( i , j ) = min ⁡ { f ( i − 1 , R i − j − k ) } + 1 f(i, j) = \min\{f(i - 1, R_i - j - k)\} + 1 f(i,j)=min{f(i−1,Ri​−j−k)}+1。

不难发现有决策单调性，于是采用单调队列维护决策点。

考虑直接枚举 $j+k$ ，然后发现这个转移要倒着枚举。

当我们翻转了两次时，还是设两面煎的时间相差 $k$，又由于翻了两次后还是这一面朝下，所以得到： f ( i , j ) = min ⁡ { f ( i − 1 , j − k ) } + 2 f(i, j) = \min\{ f(i - 1, j - k) \} + 2 f(i,j)=min{f(i−1,j−k)}+2。

同样可以用单调队列维护，但这个转移要顺着枚举了。

故总时间复杂度为 $O(NK)$ 。

然后为了保证空间不炸我开了滚动数组。

参考代码

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

const int Maxn = 200000;
const int Maxk = 100;
const int INF = 0x3f3f3f3f;

int N, K;
int L[Maxk + 5], R[Maxk + 5];

int f[2][Maxn + 5];

int q[Maxn + 5];

int main() {
#ifdef LOACL
	freopen("in.txt", "r", stdin);
	freopen("out.txt", "w", stdout);
#endif
	scanf("%d %d", &N, &K);
	for(int i = 1; i <= K; i++)
		scanf("%d %d", &L[i], &R[i]);
	memset(f[0], 0x3f, sizeof f[0]);
	f[0][0] = 0;
	int z = 1;
	for(int k = 1; k <= K; k++) {
		memcpy(f[z], f[z ^ 1], sizeof f[z]);
		int head = 1, tail = 0;
		for(int i = 0; i <= min(N, R[k]); i++) {
			while(head <= tail && f[z ^ 1][i] <= f[z ^ 1][q[tail]])
				tail--;
			q[++tail] = i;
			while(head <= tail && q[head] < i - (R[k] - L[k]))
				head++;
			f[z][i] = min(f[z][i], f[z ^ 1][q[head]] + 2);
		}
		head = 1, tail = 0;
		for(int i = R[k]; i >= 0; i--) {
			while(head <= tail && f[z ^ 1][R[k] - i] <= f[z ^ 1][q[tail]])
				tail--;
			q[++tail] = R[k] - i;
			while(head <= tail && q[head] < L[k] - i)
				head++;
			f[z][i] = min(f[z][i], f[z ^ 1][q[head]] + 1);
		}
		z ^= 1;
	}
	if(f[z ^ 1][N] >= INF) puts("Hungry");
	else printf("Full\n%d\n", f[z ^ 1][N]);
	return 0;
}