P9871 [NOIP2023] 天天爱打卡 Solution

Description

有一个 01 序列 $a=(a_1,a_2,\cdots ,a_n)$，同时有 $m$ 个三元组 $(x_i,y_i,v_i)$.
定义 $w(a)=(\sum _{i=1}^m{v}_i\times [(\sum _{j=x_i-y_i+1}^{x_i}{a}_j)=y_i])-d\times (\sum _{i=1}^n{a}_i)$.
你需要确定这个序列，使得 $w(a)$ 最大，且序列中没有超过 $k$ 个连续的 1，求这个最大值，$a$ 可以为全 0.
有 $t$ 组测试数据.

Limitations

$1\le t\le 10$
$1\le n,d,v_i\le 10^9$
$1\le m\le 10^5$
$0\le x_i-y_i<x_i\le n$
$2\text{s},512\text{MB}$

Solution

显然要 DP.
下记 $l_i=x_y-y_i+1,r_i=x_i$.
设 $f_i$ 为考虑 $a_{1\cdots i}$ 且 $a_i=1$ 的 $w(a)$ 最大值，并设 $g_i=\underset{j=1}{\overset{i}{\max }}{f}_i$.
易得 f i = max ⁡ j = i − k i { g j − 1 − ( i − j ) × d + ∑ [ l k , r k ] ⊆ ( j , i ] v p } f_i=\max\limits_{j=i-k}^i\{g_{j-1}-(i-j)\times d + \sum\limits_{[l_k,r_k]\subseteq (j,i]} v_p\} fi​=j=i−kmaxi​{gj−1​−(i−j)×d+[lk​,rk​]⊆(j,i]∑​vp​}
显然可以用线段树维护每个决策对 $w(a)$ 的影响 $h_i$，考虑 $i-1$ 转移到 $i$ 时 $h$ 如何变化.
首先 $a_{j\cdots i}$ 中全为 $1$，所以对每个 $j\in [0,i)$ 执行 $h_j\leftarrow h_j-d$.
这时满足 $r_k=i$ 的三元组就可以被选择，所以对每个 $r_k=i,j\in [0,l_k)$ 执行 $h_j\leftarrow h_j+v_k$.

然后可得 $f_i=\underset{j=i-k}{\overset{i-1}{\max }}{h}_j,g_i=max(g_{i-1},h_i)$，发现 $g_i$ 在 $j=i+1$ 时可取到，故执行 $h_{i+1}\leftarrow h_{i+1}+g_i$.

时间复杂度 $O(n\log n)$.
离散化一下，只考虑连续段即可做到 $O(m\log m)$.

Code

$3.80\text{KB},19.70\text{s},42.75\text{MB}\text{(in total, C++20 with O2)}$

// Problem: P9871 [NOIP2023] 天天爱打卡
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P9871
// Memory Limit: 512 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
using namespace std;

using i64 = long long;
using ui64 = unsigned long long;
using i128 = __int128;
using ui128 = unsigned __int128;
using f4 = float;
using f8 = double;
using f16 = long double;

template<class T>
bool chmax(T &a, const T &b){
	if(a < b){ a = b; return true; }
	return false;
}

template<class T>
bool chmin(T &a, const T &b){
	if(a > b){ a = b; return true; }
	return false;
}

const i64 inf = 1e13;
struct Node {
    int l, r;
    i64 max, tag;
};
using Tree = vector<Node>;
inline int ls(int u) { return 2 * u + 1; }
inline int rs(int u) { return 2 * u + 2; }

inline void build(Tree& tr, int u, int l, int r) {
    tr[u].l = l;
    tr[u].r = r;
    tr[u].max = -inf;
    tr[u].tag = 0;
    if (l == r) return;
    const int mid = (l + r) >> 1;
    build(tr, ls(u), l, mid);
    build(tr, rs(u), mid + 1, r);
}
inline void pushup(Tree& tr, int u) {
    tr[u].max = max(tr[ls(u)].max, tr[rs(u)].max);
}
inline void apply(Tree& tr, int u, i64 val) {
    tr[u].max += val;
    tr[u].tag += val;
}
inline void pushdown(Tree& tr, int u) {
    if (tr[u].tag) {
        apply(tr, ls(u), tr[u].tag);
        apply(tr, rs(u), tr[u].tag);
        tr[u].tag = 0;
    }
}
inline void update(Tree& tr, int u, int l, int r, i64 val) {
    if (l > r) return;
    if (l <= tr[u].l && tr[u].r <= r) return apply(tr, u, val);
    const int mid = (tr[u].l + tr[u].r) >> 1;
    pushdown(tr, u);
    if (l <= mid) update(tr, ls(u), l, r, val);
    if (r > mid) update(tr, rs(u), l, r, val);
    pushup(tr, u);
}
inline i64 query(Tree& tr, int u, int l, int r) {
    if (l <= tr[u].l && tr[u].r <= r) return tr[u].max;
    const int mid = (tr[u].l + tr[u].r) >> 1;
    i64 res = -inf;
    pushdown(tr, u);
    if (l <= mid) res = max(res, query(tr, ls(u), l, r));
    if (r > mid) res = max(res, query(tr, rs(u), l, r));
    return res;
}

inline void solve() {
    int n, m, k, d;
    scanf("%d %d %d %d", &n, &m, &k, &d);
    
    vector<array<int, 3>> A(m);
    vector<int> nums{n - 1};
    for (auto& [l, r, v] : A) {
        int x, y;
        scanf("%d %d %d", &x, &y, &v);
        nums.push_back(l = x - y + 1);
        nums.push_back(r = x);
    }
    sort(nums.begin(), nums.end());
    nums.erase(unique(nums.begin(), nums.end()), nums.end());
    for (auto& [l, r, _] : A) {
        l = lower_bound(nums.begin(), nums.end(), l) - nums.begin();
        r = lower_bound(nums.begin(), nums.end(), r) - nums.begin();
    }
    sort(A.begin(), A.end(), [&](const array<int, 3>& a, const array<int, 3>& b) {
        return a[1] < b[1];
    });
    
    vector dp(nums.size(), array<i64, 2>{-inf, -inf});
    Tree tr(nums.size() << 2);
    build(tr, 0, 0, nums.size() - 1);
    update(tr, 0, 0, 0, inf);
    for (int i = 0, j = 0, p = 0; i < nums.size(); i++) {
        if (i > 0) update(tr, 0, 0, i - 1, -d * (nums[i] - nums[i - 1]));
        while (nums[i] - nums[j] + 1 > k) j++;
        while (p < m && A[p][1] == i) {
            update(tr, 0, 0, A[p][0], A[p][2]);
            p++;
        }
        dp[i][0] = max(0LL, i > 0 ? max(dp[i - 1][0], dp[i - 1][1]) : 0LL);
        dp[i][1] = query(tr, 0, j, i) - d;
        if (i + 1 < nums.size()) {
            if (nums[i + 1] - nums[i] == 1) update(tr, 0, i + 1, i + 1, inf + dp[i][0]);
            else update(tr, 0, i + 1, i + 1, inf + max(dp[i][0], dp[i][1]));
        }
    }
    printf("%lld\n", max(dp.back()[0], dp.back()[1]));
}

signed main() {
	ios::sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	
	int c, t;
	scanf("%d %d", &c, &t);
	while (t--) solve();
	
	return 0;
}