CF794F Leha and security system 题解

题目链接：CF 或者 洛谷

首先观察到题目的修改 \(x \rightarrow y\)，是每个位置的 \(x\) 都要变，那就显然的拆位去算每一位的贡献。当然，你又发现 \(x \rightarrow y\)，这玩意属于值为 \(x\) 的位变化成 \(y\)，那么这个和普通的拆位区别就在于这是维护值域维的拆位，我们拆位 \(0 \sim 9\) 这十个数字的拆位贡献，那么修改就可以看做拆位以后的区间覆盖，维护覆盖标记即可，区间查询即可。

细节：

可以考虑维护 \(10\) 棵线段树，也可以考虑一个线段树维护 \(10\) 种数的覆盖标记和区间贡献和，当然这个也可以状态压缩优化空间复杂度，为了可读性，就没使用状态压缩的 \(coverTag\)。考虑 \(pushDown\) 操作依次将 \(10\) 种标记下传，由于存在标记互相影响：

比如 \(0 \rightarrow 1\)，\(1 \rightarrow 2\)，由于我们标记下传是不知道这个实际覆盖序，而是从 \(0 \sim 9\) 依次下传每种覆盖标记，所以我们必须要拷贝一份原来的，统一在同一个原来的区间贡献和区间覆盖标记上进行修改，这样就互不影响了，其实就和滚动数组的交换是一个原理，我们需要基于同一个上一份数据进行修改，新的数据之间可能会互相影响。

参照代码

#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;
#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 = 1e5 + 10;
constexpr int T = 9;
int ten[T + 1];

struct Node
{
    ll val[T + 1];
    int tag[T + 1];
} node[N << 2], tmp[N << 2];

#define val(x,y) node[x].val[y]
#define tag(x,y) node[x].tag[y]
#define tmpVal(x,y) tmp[x].val[y]
#define tmpTag(x,y) tmp[x].tag[y]

inline void pushUp(const int curr)
{
    forn(i, 0, T)
    {
        val(curr, i) = val(ls(curr), i) + val(rs(curr), i);
    }
}

inline void tagUpdate(const int curr, const int x, const int y)
{
    val(curr, y) += tmpVal(curr, x);
    val(curr, x) -= tmpVal(curr, x);
    forn(i, 0, T)
    {
        if (tmpTag(curr, i) == x)
        {
            tag(curr, i) = y;
        }
    }
}

inline void pushDown(const int curr)
{
    tmp[ls(curr)] = node[ls(curr)];
    tmp[rs(curr)] = node[rs(curr)];
    forn(i, 0, T)
    {
        if (tag(curr, i) != i)
        {
            tagUpdate(ls(curr), i,tag(curr, i));
            tagUpdate(rs(curr), i,tag(curr, i));
            tag(curr, i) = i;
        }
    }
}

int n, q;

inline void build(const int curr = 1, const int l = 1, const int r = n)
{
    const int mid = l + r >> 1;
    forn(i, 0, T)
    {
        tag(curr, i) = i;
    }
    if (l == r)
    {
        int i = 0, x;
        cin >> x;
        while (x)
        {
            val(curr, x%10) += ten[i++];
            x /= 10;
        }
        return;
    }
    build(ls(curr), l, mid), build(rs(curr), mid + 1, r);
    pushUp(curr);
}

inline void cover(const int curr, const int l, const int r, const int x, const int y, const int s = 1, const int e = n)
{
    if (x == y) return;
    if (l <= s and e <= r)
    {
        tmp[curr] = node[curr];
        tagUpdate(curr, x, y);
        return;
    }
    const int mid = s + e >> 1;
    pushDown(curr);
    if (l <= mid) cover(ls(curr), l, r, x, y, s, mid);
    if (r > mid) cover(rs(curr), l, r, x, y, mid + 1, e);
    pushUp(curr);
}

inline ll query(const int curr, const int l, const int r, const int s = 1, const int e = n)
{
    ll ans = 0;
    if (l <= s and e <= r)
    {
        forn(i, 0, T) ans += i * val(curr, i);
        return ans;
    }
    const int mid = s + e >> 1;
    pushDown(curr);
    if (l <= mid) ans += query(ls(curr), l, r, s, mid);
    if (r > mid) ans += query(rs(curr), l, r, mid + 1, e);
    return ans;
}

inline void solve()
{
    cin >> n >> q;
    ten[0] = 1;
    forn(i, 1, T) ten[i] = 10 * ten[i - 1];
    build();
    while (q--)
    {
        int op, l, r;
        cin >> op >> l >> r;
        if (op == 1)
        {
            int x, y;
            cin >> x >> y;
            cover(1, l, r, x, y);
        }
        else cout << query(1, l, r) << endl;
    }
}

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;
}

注意到 \(n,q\le 1e5\)，所以我们有：

\[时间复杂度最坏为:\ O(100 \times n\log{n}) \sim O(1e7 \times \log{n}) \sim O(2e8) \]