CF1764H Doremy's Paint 2 题解

题目链接：CF 或者 洛谷

高分题，感觉挺有意思的题，值得一提的是这个题的 \(1\) 和 \(3\) 版本却是两个基础题。

一开始以为跟这道差不多：P8512 [Ynoi Easy Round 2021] TEST_152 题解。后面重新读了一下发现一个有趣的点：

也就是是说操作的 \(val\) 并不太好搞了，如果 \(val\) 确定就基本上一样，跑个扫描线，然后 ODT 和 BIT 计数和维护下就行了。那咋整呢，现在我们其实还是可以沿用差不多的离线贡献计数，不过我们现在需要把目光放在 \(val\) 和询问的答案关系了。

先关注问什么，全局颜色数，又是这类较为经典的问题。我们重新审题会读到一个有意思的点：

重新读一下题目和样例一手玩下看看，很容易发现一个性质：同种颜色段总是连续的，而且有且只有一段，因为每次修改操作都会使得右边的所有颜色被覆盖为 \(a_l\) 的颜色。这个和常规的覆盖为任意颜色是有区别的，也就是每次覆盖为连续段相邻的位置的一种颜色，那么很显然，无论如何，都不可能让相同颜色的连续段不再连续。这个样例一就比较明显了，可以看的出来任意相同的颜色只会连续分布。而且很容易观察到修改的作用：拓展一个颜色的作用范围，同时有概率地使得某一个颜色消失，种类数减少。

说到全局颜色数，以及颜色会消失，其实有一道挺经典的题：P9247 [集训队互测 2018] 完美的队列题解。其实根据这题我们基本上就知道咋做了，考虑每个颜色的影响时间，当这个颜色被删去的时候，就会贡献 \(-1\)，所以我们可以考虑每种颜色的作用时间即可，而查询的话很简单，比如对某个 \([i,i+k-1]\) 进行查询，显然我们需要查询的是 \(消失时间>i+k-1\) 的个数。即是在最后一个操作结束以后才消失的颜色个数，因为这些颜色会在还没结束操作前依旧产生影响。时间显然有个上界：\(2m\)。我们不妨把它作为 \(INF\)，类似那题的人为规定，在 \(INF\) 操作以后，无论还有没有颜色，都将剩余颜色全部删除。那么这玩意就是一个树状数组求 \((i+k-1,INF]\) 的和即可。

现在回到这个颜色影响上，考虑这种操作会对颜色消失时间产生什么影响：

首先明确一点，当有一个修改区间为 \([L,R]\) 包含了某个区间 \([l,r]\) 的时候，显然这个 \([l,r]\) 区间内所有数都会受到影响，它们都会变为了 \(a_L\)，那么很显而易见的一点就是，这个时候 \(a_L\) 的作用范围增加了，\(a_L\) 作用范围来到了 \([L,R]\)，这个时候很显而易见的是 \([l,r]\) 上的数在此时此刻被 \(a_L\) 覆盖了，被删除了。但要注意到一个特殊的点：\(a_L\) 对应的颜色却没被删除，只是被拓展了，所以我们着重思考下 \(a_L\) 的删除时间是多少，其他的点删除时间显然就是当前的 \(i\) 时刻。我们首先知道了一个点：\(a_L\) 在第 \(i\) 时刻作用范围来到了 \([L,R]\)，如果后续没有拓展的情况下，很显然需要当 \([L,R]\) 内所有的 \(a_i\) 都被删掉，即 \(t_L=\max(t_i)(i \in (L,R]\)。

显然 \([L,R]\) 这个区间内假如全为绿色的颜色，而后续的一些操作，会逐步地删除这个区间内的某部分点，显然最终这个颜色被删除的时间为这个区间内的所有点的最后一个删除时间，这个其实就是和那道“完美的队列”一样了，考虑某个颜色的作用时间为这个颜色包含的点里面的最后一个被删除的时间。那么很显然这里分区间长度是否为 \(1\) 更改两部分的删除时间即可。当然这题显然我们需要断环为链一下，让操作为线性执行。另外时间上界为 \(INF=2*m\)，树状数组别写成了 \(m\) 了。

接下来考虑下怎么求出这个最后的删除时间，显而易见的是，最开始没有操作的删除时间都是最后 \(INF\)，而我们注意到一点，如果你是按顺序遍历操作，由于前一个操作需要知道 后面操作造成的影响：即后面操作导致的最后删除时间 。因为某个位置的删除时间显然是由最后的操作受影响的，所以我们可以考虑倒序扫描线考虑操作，这样一来，每一个操作我们的 \(a_L\) 都能拿到 \([L,R]\) 区间内受到后面操作影响的最终删除时间。

最后，考虑操作产生的颜色贡献问题。树状数组和第一个推荐的题一样的用法，记录时刻前缀和，即轴为时间轴。初始的时候，显然有 \(n\) 种颜色，而且应该在 \(INF\) 时刻，因为我们是从最后一刻倒序往前面时刻更新。考虑每个操作的影响，显然由于 \([L+1,R]\) 的数被删掉了，所以它们原有的影响也应该删除，这里我们使用 \(ODT\) 维护相同的删除时刻的区间段。显然原本它们可以对删除时间为 \(t_{val}\) 以后的时间段产生颜色贡献，现在显然不能了。而 \([l,r]\) 上显然有 \(r-l+1\) 个颜色会取消掉它们对 \(t_{val}\) 以后的贡献。而显然应该更新一个 \(last\) 时刻以后，当前的 \(a_L\) 可以产生 \(1\) 贡献的情况。然后如果存在 \([l+1,r]\)，它们的贡献时间显然变为了从 \(i\) 时刻开始。就是说 \(ODT\) 怎么变，\(BIT\) 对应贡献也怎么变就行了，只需要更改在时间轴上保证删除时间 \(>t_{last}\) 才有贡献即可。这里需要反复纠正一点，我们记录的最后删除时间其实是指的是当前位置颜色到最后首次被完全覆盖的时间，而有些人会疑惑，如果当前查询的时候，如果有些位置出现了相同的颜色，不就不对了？因为比如 \(2\) 和 \(3\) 位置都是绿色，我们显然是它两个同时被删除才算一种颜色？所以这就是这题的魅力，初始 \(a_i=i\)，当我们不断回滚到初始位置时，会发现这个时候查询完全正确，因为每个位置的颜色都是不相同的，这个时候算出 \(time_{del}>last_{r}\) 的数量即为答案，否则很显然，你算出的删除时间的数量里面如果有例如前文提到的有两个绿色位置删除时间都满足，显然重复计数了。这也是我写代码时不断感慨比较这题设计得好的地方。

参照代码

#include <bits/stdc++.h>

// #pragma GCC optimize(2)
// #pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,avx2,popcnt,tune=native")

// #define isPbdsFile

#ifdef isPbdsFile

#include <bits/extc++.h>

#else

#include <ext/pb_ds/priority_queue.hpp>
#include <ext/pb_ds/hash_policy.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/trie_policy.hpp>
#include <ext/pb_ds/tag_and_trait.hpp>
#include <ext/pb_ds/hash_policy.hpp>
#include <ext/pb_ds/list_update_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/exception.hpp>
#include <ext/rope>

#endif

using namespace std;
using namespace __gnu_cxx;
using namespace __gnu_pbds;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef tuple<int, int, int> tii;
typedef tuple<ll, ll, ll> tll;
typedef unsigned int ui;
typedef unsigned long long ull;
typedef __int128 i128;
#define hash1 unordered_map
#define hash2 gp_hash_table
#define hash3 cc_hash_table
#define stdHeap std::priority_queue
#define pbdsHeap __gnu_pbds::priority_queue
#define sortArr(a, n) sort(a+1,a+n+1)
#define all(v) v.begin(),v.end()
#define yes cout<<"YES"
#define no cout<<"NO"
#define Spider ios_base::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
#define MyFile freopen("..\\input.txt", "r", stdin),freopen("..\\output.txt", "w", stdout);
#define forn(i, a, b) for(int i = a; i <= b; i++)
#define forv(i, a, b) for(int i=a;i>=b;i--)
#define ls(x) (x<<1)
#define rs(x) (x<<1|1)
#define endl '\n'
//用于Miller-Rabin
[[maybe_unused]] static int Prime_Number[13] = {0, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37};

template <typename T>
int disc(T* a, int n)
{
    return unique(a + 1, a + n + 1) - (a + 1);
}

template <typename T>
T lowBit(T x)
{
    return x & -x;
}

template <typename T>
T Rand(T l, T r)
{
    static mt19937 Rand(time(nullptr));
    uniform_int_distribution<T> dis(l, r);
    return dis(Rand);
}

template <typename T1, typename T2>
T1 modt(T1 a, T2 b)
{
    return (a % b + b) % b;
}

template <typename T1, typename T2, typename T3>
T1 qPow(T1 a, T2 b, T3 c)
{
    a %= c;
    T1 ans = 1;
    for (; b; b >>= 1, (a *= a) %= c)if (b & 1)(ans *= a) %= c;
    return modt(ans, c);
}

template <typename T>
void read(T& x)
{
    x = 0;
    T sign = 1;
    char ch = getchar();
    while (!isdigit(ch))
    {
        if (ch == '-')sign = -1;
        ch = getchar();
    }
    while (isdigit(ch))
    {
        x = (x << 3) + (x << 1) + (ch ^ 48);
        ch = getchar();
    }
    x *= sign;
}

template <typename T, typename... U>
void read(T& x, U&... y)
{
    read(x);
    read(y...);
}

template <typename T>
void write(T x)
{
    if (typeid(x) == typeid(char))return;
    if (x < 0)x = -x, putchar('-');
    if (x > 9)write(x / 10);
    putchar(x % 10 ^ 48);
}

template <typename C, typename T, typename... U>
void write(C c, T x, U... y)
{
    write(x), putchar(c);
    write(c, y...);
}

template <typename T11, typename T22, typename T33>
struct T3
{
    T11 one;
    T22 tow;
    T33 three;

    bool operator<(const T3 other) const
    {
        if (one == other.one)
        {
            if (tow == other.tow)return three < other.three;
            return tow < other.tow;
        }
        return one < other.one;
    }

    T3() { one = tow = three = 0; }

    T3(T11 one, T22 tow, T33 three) : one(one), tow(tow), three(three)
    {
    }
};

template <typename T1, typename T2>
void uMax(T1& x, T2 y)
{
    if (x < y)x = y;
}

template <typename T1, typename T2>
void uMin(T1& x, T2 y)
{
    if (x > y)x = y;
}

constexpr int N = 4e5 + 10;

struct ODT
{
    int l, r;
    mutable int tim;

    ODT(const int l, const int r, const int tim)
        : l(l),
          r(r),
          tim(tim)
    {
    }

    bool operator<(const ODT& other) const
    {
        return l < other.l;
    }
};

set<ODT> node;
typedef set<ODT>::iterator iter;
int n, m, k;
int bit[N];
//轴为时间轴的树状数组
inline void add(int x, const int val)
{
    while (x <= 2 * m)bit[x] += val, x += lowBit(x);
}
//查询
inline int query(int x)
{
    int ans = 0;
    while (x)ans += bit[x], x -= lowBit(x);
    return ans;
}

int ans[N];

inline iter split(const int pos)
{
    auto it = node.lower_bound(ODT(pos, 0, 0));
    if (it != node.end() and it->l == pos)return it;
    --it;
    if (it->r < pos)return node.end();
    auto [l,r,tim] = *it;
    node.erase(it), node.insert(ODT(l, pos - 1, tim));
    return node.insert(ODT(pos, r, tim)).first;
}

//覆盖
inline void assign(const int Time, const int l, const int r)
{
    auto itr = split(r + 1), itl = split(l);
    int last = 0; //这个区间内最后删除的时间
    for (auto it = itl; it != itr; ++it)
    {
        auto [L,R,tim] = *it;
        add(tim, -(R - L + 1)); //去掉每种颜色
        uMax(last, tim);
    }
    node.erase(itl, itr), node.emplace(l, l, last), add(last, 1); //加入a_l位置贡献
    if (l != r)node.emplace(l + 1, r, Time), add(Time, r - l); //存在[l+1,r]就如题解覆盖新的最后颜色删除时间
}

int L[N], R[N]; //操作

inline void solve()
{
    cin >> n >> m >> k;
    forn(i, 1, m)cin >> L[i] >> R[i];
    forn(i, m+1, 2*m)L[i] = L[i - m], R[i] = R[i - m]; //断环为链,预处理操作
    const int INF = 2 * m; //最后操作时间
    node.emplace(1, n, INF), add(INF, n); //人为规定,操作结束以后全部颜色删除
    forv(i, m+k-1, 1)
    {
        assign(i, L[i], R[i]);
        if (i <= m)ans[i] = query(INF) - query(i + k - 1); //最巧妙的一点,初始的时候每个位置颜色互不相同
    }
    forn(i, 1, m)cout << ans[i] << ' ';
}

signed int main()
{
    // MyFile
    Spider
    //------------------------------------------------------
    // clock_t start = clock();
    int test = 1;
    //    read(test);
    // cin >> test;
    forn(i, 1, test)solve();
    //    while (cin >> n, n)solve();
    //    while (cin >> test)solve();
    // clock_t end = clock();
    // cerr << "time = " << double(end - start) / CLOCKS_PER_SEC << "s" << endl;
}

\[
时间复杂度为：\ O(n\log{2m})
\]