Comet OJ

想出来感觉挺容易， 码得好麻烦啊。。。

把每个点分为轻点和重点， 给轻点的信息直接修改， 重点建个字典树去维护。

#include<bits/stdc++.h>
#define LL long long
#define LD long double
#define ull unsigned long long
#define fi first
#define se second
#define mk make_pair
#define PLL pair<LL, LL>
#define PLI pair<LL, int>
#define PII pair<int, int>
#define SZ(x) ((int)x.size())
#define ALL(x) (x).begin(), (x).end()
#define fio ios::sync_with_stdio(false); cin.tie(0);

using namespace std;

const int N = 131071 + 10;
const int inf = 0x3f3f3f3f;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 998244353;
const double eps = 1e-8;
const double PI = acos(-1);

template<class T, class S> inline void add(T& a, S b) {a += b; if(a >= mod) a -= mod;}
template<class T, class S> inline void sub(T& a, S b) {a -= b; if(a < 0) a += mod;}
template<class T, class S> inline bool chkmax(T& a, S b) {return a < b ? a = b, true : false;}
template<class T, class S> inline bool chkmin(T& a, S b) {return a > b ? a = b, true : false;}

const int B = 1000;
const int Log = 17;

int n, m, q, b[N];
int X[N], Y[N], Z[N];
int belong[N];

int deg[N];
bool big[N];

vector<PII> LG[N];
vector<PII> HG[N];
vector<int> bigP;

struct Bit {
    int a[N];
    int zero;
    inline void Add(int x, int v) {
        if(x) {
            for(int i = x; i < N; i += i & -i) add(a[i], v);
        } else add(zero, v);
    }
    inline void Sub(int x, int v) {
        if(x) {
            for(int i = x; i < N; i += i & -i) sub(a[i], v);
        } else sub(zero, v);
    }
    inline int sum(int x) {
        if(x < 0) return 0;
        int ans = zero;
        for(int i = x; i; i -= i & -i) add(ans, a[i]);
        return ans;
    }
    inline int query(int L, int R) {
        if(L > R) return 0;
        return (sum(R) - sum(L - 1) + mod) % mod;
    }
} bit;

struct Trie {
    int stk[N * 25], top;
    int sum[N * 25], ch[N * 25][2], cnt[N * 25];
    int Rt[N];
    inline int newNode() {
        int x = stk[top--];
        cnt[x] = sum[x] = ch[x][0] = ch[x][1] = 0;
        return x;
    }
    void init() {
        for(int i = 1; i < N * 25; i++) stk[++top] = i;
        for(int i = 1; i <= n; i++) if(big[i]) Rt[i] = newNode();
    }
    void del(int x, int v, int u) {
        for(int i = Log - 1; i >= 0; i--) {
            int to = ch[u][x >> i & 1];
            if(i != Log - 1 && !cnt[u]) stk[++top] = u;
            sub(sum[to], v);
            cnt[to]--;
            if(!cnt[to]) ch[u][x >> i & 1] = 0;
            u = to;
        }
        if(!cnt[u]) stk[++top] = u;
    }
    void ins(int x, int v, int u) {
        for(int i = Log - 1; i >= 0; i--) {
            if(!ch[u][x >> i & 1]) ch[u][x >> i & 1] = newNode();
            int to = ch[u][x >> i & 1];
            add(sum[to], v);
            cnt[to]++;
            u = to;
        }
    }
    int query(int x, int b, int u) {
        int ans = 0;
        for(int i = Log - 1; i >= 0 && u; i--) {
            if(!(b >> i & 1)) {
                if(x >> i & 1) {
                    add(ans, sum[ch[u][0]]);
                    u = ch[u][1];
                } else u = ch[u][0];
            } else {
                if(x >> i & 1) {
                    add(ans, sum[ch[u][1]]);
                    u = ch[u][0];
                } else u = ch[u][1];
            }
        }
        if(u) add(ans, sum[u]);
        return ans;
    }
} trie;

int main() {
    scanf("%d%d%d", &n, &m, &q);
    for(int i = 1; i <= n; i++) scanf("%d", &b[i]);
    for(int i = 1; i <= m; i++) {
        scanf("%d%d%d", &X[i], &Y[i], &Z[i]);
        if(X[i] > Y[i]) swap(X[i], Y[i]);
        deg[X[i]]++; deg[Y[i]]++;
    }
    for(int i = 1; i <= n; i++) {
        big[i] = deg[i] > B;
        if(big[i]) bigP.push_back(i);
    }
    for(int i = 1; i <= m; i++) {
        if(deg[X[i]] >= deg[Y[i]]) belong[i] = X[i];
        else belong[i] = Y[i];
        if(big[Y[i]]) HG[X[i]].push_back(mk(Y[i], i));
        else LG[X[i]].push_back(mk(Y[i], i));
        if(big[X[i]]) HG[Y[i]].push_back(mk(X[i], i));
        else LG[Y[i]].push_back(mk(X[i], i));
    }

    for(int i = 1; i <= m; i++) {
        if(!big[belong[i]]) {
            bit.Add(b[X[i]] ^ b[Y[i]], Z[i]);
        }
    }
    trie.init();
    for(int i = 1; i <= m; i++) {
        int who = belong[i];
        int x = who == X[i] ? Y[i] : X[i];
        if(big[who]) trie.ins(b[x], Z[i], trie.Rt[who]);
    }
    while(q--) {
        int type, u, v; scanf("%d%d%d", &type, &u, &v);
        if(type == 1) {
            if(!big[u]) {
                for(auto& t : HG[u]) trie.del(b[u], Z[t.se], trie.Rt[t.fi]);
                for(auto& t : LG[u]) {
                    bit.Sub(b[u] ^ b[t.fi], Z[t.se]);
                    bit.Add(v ^ b[t.fi], Z[t.se]);
                }
                b[u] = v;
                for(auto& t : HG[u]) trie.ins(b[u], Z[t.se], trie.Rt[t.fi]);
            } else {
                for(auto& t : HG[u]) {
                    if(deg[t.fi] < deg[u] || deg[t.fi] == deg[u] && u < t.fi) continue;
                    trie.del(b[u], Z[t.se], trie.Rt[t.fi]);
                }
                b[u] = v;
                for(auto& t : HG[u]) {
                    if(deg[t.fi] < deg[u] || deg[t.fi] == deg[u] && u < t.fi) continue;
                    trie.ins(b[u], Z[t.se], trie.Rt[t.fi]);
                }
            }
        } else if(type == 2) {
            int who = belong[u];
            int x = who == X[u] ? Y[u] : X[u];
            if(big[who]) {
                trie.del(b[x], Z[u], trie.Rt[who]);
                Z[u] = v;
                trie.ins(b[x], Z[u], trie.Rt[who]);
            } else {
                int change = v - Z[u];
                if(change < 0) change += mod;
                bit.Add(b[X[u]] ^ b[Y[u]], change);
                Z[u] = v;
            }
        } else {
            int ans = bit.query(u, v);
            for(auto &id : bigP) {
                add(ans, trie.query(v, b[id], trie.Rt[id]));
                if(u) sub(ans, trie.query(u - 1, b[id], trie.Rt[id]));
            }
            printf("%d
", ans);
        }
    }
    return 0;
}

/*
*/