2021hdu多校第八场补题

1004-Counting Stars

思路：
看见区间求和就感觉是一道线段树的题目，问题是怎么去维护两种操作。

第一个操作（lowbit）不是很好维护，但是我们计算复杂度之后可以发现，对于每一个数字暴力修改lowbit操作的复杂度是$logn$的，那么对于每次操作最多复杂度就是$nlogn$，加上线段树本身的复杂度就是$nlo{g}^{2}n$，所以可以直接暴力单点修改。

第二个操作翻译之后其实就是将这个数的最高位的1左移一位，对一个区间进行此操作其实就是将整个区间的最高位的1的加和左移一位，如此考虑我们就可以将最高位的1的加和与剩余位的加和分开维护，最后求和的时候将其相加就行。

需要注意的是我们暴力修改的时候也需要将懒标记下传，否则暴力修改的数不是真实的数。

代码：

#include<bits/stdc++.h>
#define endl '\n'
#define lson t << 1
#define rson t << 1 | 1
#define lowbit(x) (x&-x)
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0)
using namespace std;

typedef pair<int, int> PII;
typedef long long ll;
const int N = 1e5 + 100;
const int mod = 998244353;
ll pp[N];

void init() {
    pp[0] = 1;
    for(int i = 1; i <= N; ++ i) pp[i] = pp[i - 1] * 2 % mod;
}

int getcnt(int x) {
    int res = 0;
    for( ; x; x -= lowbit(x)) res ++;
    return res;
}

int getup(int x) {
    for(int i = 30; i >= 0; -- i) if((x >> i) & 1) return 1 << i;
    return 0;
}

struct segment_tree{
    int lazy[N << 2];
	ll cnt[N << 2], up[N << 2], low[N << 2];

    void build(int l, int r, int t) {
        lazy[t] = up[t] = low[t] = cnt[t] = 0;
        if(l == r) {
            int x; cin >> x;
            cnt[t] = getcnt(x), up[t] = getup(x), low[t] = x - up[t];
            return ;
        }
        int mid = (l + r) >> 1;
        build(l, mid, lson), build(mid + 1, r, rson);
        pushup(t);
    }

    void pushup(int t) {
        up[t] = (up[lson] + up[rson]) % mod; 
        low[t] = (low[lson] + low[rson]) % mod;
        cnt[t] = max(cnt[lson], cnt[rson]);
    }

    void pushdown(int t) {
        if(lazy[t]) {
            int lz = lazy[t];
            lazy[t] = 0;
            lazy[lson] += lz, lazy[rson] += lz;
	        up[lson] = up[lson] * pp[lz] % mod;
	        up[rson] = up[rson] * pp[lz] % mod;
		}
    }

    void upd1(int l, int r, int t, int L, int R) {
        if(cnt[t] == 0) return ;
        if(l > R || r < L) return ;
        if(l == r) {
            cnt[t] --, low[t] -= lowbit(low[t]);
            if(cnt[t] == 0) up[t] = 0;
            return ;
        }
        pushdown(t);
        int mid = (l + r) >> 1;
        upd1(l, mid, lson, L, R), upd1(mid + 1, r, rson, L, R);
        pushup(t);
    }

    void upd2(int l, int r, int t, int L, int R) {
        if(L <= l && r <= R) {
            up[t] = up[t] * 2 % mod;
            lazy[t] ++;
            return ;
        }
        pushdown(t);
        int mid = (l + r) >> 1;
        if(mid >= L) upd2(l, mid, lson, L, R);
        if(R > mid) upd2(mid + 1, r, rson, L, R);
        pushup(t);
    }

    ll query(int l, int r, int t, int L, int R) {
        if(L <= l && r <= R)    
            return (low[t] + up[t]) % mod;
        pushdown(t);
        int mid = (l + r) >> 1;
        ll res = 0;
        if(mid >= L) res = (res + query(l, mid, lson, L, R)) % mod;
        if(R > mid) res = (res + query(mid + 1, r, rson, L, R)) % mod;
        return res % mod;
    }
}Tree;

void solve() { 
    int n, q;
    cin >> n;
    Tree.build(1, n, 1);
    cin >> q;
    while(q --) {
        int op, x, y;
        cin >> op >> x >> y;
        if(op == 1) cout << Tree.query(1, n, 1, x, y) % mod << endl;
        else if(op == 2) Tree.upd1(1, n, 1, x, y);
        else Tree.upd2(1, n, 1, x, y);
    }
}

int main() {
    IOS;
    init();
    int t;
    cin >> t;
    while(t --) solve();
    return 0;
}