939F - Cutlet DP 线段树优化

题意

有一块烤肉，每面都需要烤正好n秒钟。

现在给k个区间，你可以在这些区间内翻转烤肉。

求最少的翻转次数。

k<=100.

n<=1e5

题解

首先要知道，在同一个区间内，不可能翻转超过两次， 如果翻转超过两次，可以用两次以内来代替。

我们定义dp[i][j]表示在第i个区间完成后，当前未烤的那面烤了j分钟。为什么不定义正在烤的那面烤了j分钟呢？因为前者结果可以轻松表示为dp[k][n]。

假设当前i这个区间内我们翻转了两次烤肉，dp[i][j] = min(dp[i - 1][j - k] + 2) （k<= r[i] - l[i] 表示翻转的区间长度）

假设当前区间翻转了一次，dp[i][j] = min(dp[i - 1][r[i] - j - k]) (k <= r[i] - l[i])。

当前区间没翻 dp[i][j] = dp[i - 1][j]。

这个DP时间复杂度 （n^2 * k）。

可以用线段树求最小值，优化到(n * k * logn)

代码

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <queue>
#include <bitset>
#include <map>
#include <vector>
#include <set>
#include <unordered_set>
#include <cmath>
#ifdef LOCAL
#define debug(x) cout<<#x<<" = "<<(x)<<endl;
#else
#define debug(x) 1;
#endif

#define lson id<<1,l,mid
#define rson id<<1|1,mid+1,r
#define lowbit(x) x&-x
#define mp make_pair
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int MOD = 1e9 + 7;
const double eps = 1e-10;
const int INF = 0x3f3f3f3f;
const ll INFLL = 0x3f3f3f3f3f3f3f3fll;
const int MAXN = 2e5 + 5;
const int mod = 1e9 + 7;


int l[123], r[123];

int d[2][MAXN];
int tree[MAXN * 4];

void build(int id, int l, int r, int now) {
    if(l == r) {
        tree[id] = d[now][l];
        return ;
    }
    int mid = (l + r) >> 1;
    build(lson, now);
    build(rson, now);
    tree[id] = min(tree[id<<1], tree[id<<1|1]);
}

int query(int id, int l, int r, int L, int R) {
    if(L <= l && R >= r) return tree[id];
    int mid = (l + r) >> 1, ret = INF;
    if(L <= mid) ret = min(ret, query(lson, L, R));
    if(R > mid) ret = min(ret, query(rson, L, R));
    return ret;
}


int main() {
#ifdef LOCAL
    freopen ("input.txt", "r", stdin);
#endif
    int n,K;
    scanf("%d %d", &n, &K);
    for(int i = 1; i <= K; i++) scanf("%d %d", &l[i], &r[i]);
    memset(d, 0x3f, sizeof(d));
    d[0][0] = 0;
    n *= 2;
    build(1, 0, n, 0);
    for(int i = 1; i <= K; i++) {
        int ll = r[i] - l[i] + 1;
        for(int j = 0; j <= r[i]; j++) {
            d[i&1][j] = min(d[i&1][j], query(1, 0, n, max(j - ll + 1, 0), j) + 2);
            d[i&1][j] = min(d[i&1][j], query(1, 0, n, max(r[i] - j - ll + 1, 0), r[i] - j) + 1);
            d[i&1][j] = min(d[i&1][j], d[i&1^1][j]);
        }
        build(1, 0, n, i&1);
        memset(d[i&1^1], 0x3f, sizeof(d[i&1^1]));
    }
    if(d[K&1][n/2] < INF/2) printf("Full\n%d\n", d[K&1][n/2]);
    else puts("Hungry");
    return 0;
}
/*
    d[i][j] = min(d[i - 1][j - k] + 2)
    d[i][j] = min(d[i - 1][r[i] - j - k] + 1)
    d[i][j] = d[i - 1][j]
*/