代码打印-test

#include <bits/stdc++.h>
#include <unordered_map>
using namespace std;
#define int long long
const int MAXN = 1e5 + 5;
int n, m;
int a[MAXN];
int block_size;

struct Block {
    vector<int> original;
    int add;
    unordered_map<int, int> replace_map;
    unordered_map<int, int> freq;
    int l, r;

    Block() : add(0) {}

    void init(int* arr, int start, int end) {
        l = start;
        r = end;
        original.resize(end - start + 1);
        for (int i = 0; i <= end - start; ++i) {
            original[i] = arr[start + i];
            freq[original[i]]++;
        }
    }

    void apply() {
        for (int& val : original) {
            if (replace_map.find(val) != replace_map.end()) {
                val = replace_map[val];
            }
            val += add;
        }
        replace_map.clear();
        add = 0;
        freq.clear();
        for (int val : original) {
            freq[val]++;
        }
    }

    void op1(int x, int y) {
        unordered_map<int, int> new_freq;
        unordered_map<int, int> new_replace = replace_map;

        for (auto it = freq.begin(); it != freq.end(); ++it) {
            int current = it->first;
            if (new_replace.find(current) != new_replace.end()) {
                current = new_replace[current];
            }
            current += add;

            if (current == x) {
                int new_k = y - add;
                new_replace[it->first] = new_k;
                new_freq[new_k] += it->second;
            }
            else {
                new_freq[it->first] += it->second;
            }
        }

        replace_map = new_replace;
        freq.swap(new_freq);
    }

    void op2(int x) {
        add += x;
    }

    int query(int x) {
        int res = 0;
        int target = x - add;
        for (auto it = freq.begin(); it != freq.end(); ++it) {
            int val = it->first;
            if (replace_map.find(val) != replace_map.end()) {
                val = replace_map[val];
            }
            if (val + add == x) {
                res += it->second;
            }
        }
        return res;
    }
};

vector<Block> blocks;

void build() {
    block_size = sqrt(n);
    int num_blocks = (n + block_size - 1) / block_size;
    blocks.resize(num_blocks);
    for (int i = 0; i < num_blocks; ++i) {
        int start = i * block_size;
        int end = min(n - 1, start + block_size - 1);
        blocks[i].init(a, start, end);
    }
}

void process_op0(int l, int r, int x) {
    l--; r--;
    int ans = 0;
    for (auto& blk : blocks) {
        if (blk.r < l || blk.l > r) continue;
        if (blk.l >= l && blk.r <= r) {
            ans += blk.query(x);
        }
        else {
            blk.apply();
            int ol = max(l, blk.l);
            int or_ = min(r, blk.r);
            for (int i = ol; i <= or_; ++i) {
                int pos = i - blk.l;
                if (blk.original[pos] == x) {
                    ans++;
                }
            }
        }
    }
    cout << ans << '\n';
}

void process_op1(int l, int r, int x, int y) {
    l--; r--;
    for (auto& blk : blocks) {
        if (blk.r < l || blk.l > r) continue;
        if (blk.l >= l && blk.r <= r) {
            blk.op1(x, y);
        }
        else {
            blk.apply();
            int ol = max(l, blk.l);
            int or_ = min(r, blk.r);
            for (int i = ol; i <= or_; ++i) {
                int pos = i - blk.l;
                int& val = blk.original[pos];
                if (val == x) {
                    blk.freq[val]--;
                    if (blk.freq[val] == 0) {
                        blk.freq.erase(val);
                    }
                    val = y;
                    blk.freq[val]++;
                }
            }
        }
    }
}

void process_op2(int l, int r, int x) {
    l--; r--;
    for (auto& blk : blocks) {
        if (blk.r < l || blk.l > r) continue;
        if (blk.l >= l && blk.r <= r) {
            blk.op2(x);
        }
        else {
            blk.apply();
            int ol = max(l, blk.l);
            int or_ = min(r, blk.r);
            for (int i = ol; i <= or_; ++i) {
                int pos = i - blk.l;
                blk.original[pos] += x;
            }
            blk.init(&blk.original[0], blk.l, blk.r);
        }
    }
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> n >> m;
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }

    build();

    while (m--) {
        int op;
        cin >> op;
        if (op == 0) {
            int l, r, x;
            cin >> l >> r >> x;
            process_op0(l, r, x);
        }
        else if (op == 1) {
            int l, r, x, y;
            cin >> l >> r >> x >> y;
            process_op1(l, r, x, y);
        }
        else if (op == 2) {
            int l, r, x;
            cin >> l >> r >> x;
            process_op2(l, r, x);
        }
    }

    return 0;
}