A - Lowbit（势能线段树+思维）

分析

因为本题并不是对某一区间进行同一操作，而是对每个数加他的lowbit值，所以我们不能用基础的线段树来解决。我们通过分析lowbit的性质我们会发现一个数如果一直加他的lowbit，在最多log次后这个数每次加lowbit的操作就会变成乘2的操作，如果某一区间中所有元素都满足了这个性质， 我们便可以在modify操作中实现快速的区间修改，而不是递归到每一个元素，进行暴力修改。使用势能线段树，比普通线段树多维护一个flag，同时在pushup操作中不段向上更新。最坏进行nlog次O（n）的暴力操作，之后的所有操作均进化为 log n的操作，很大程度优化了暴力解法。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int long long
#define endl '\n'
#define mh(x) memset(x, -1, sizeof x)
#define debug(x) cerr << #x << "=" << x << endl;
const int N = 1e5 + 10;
const int mod = 998244353;
int a[N];
int read()
{
    int x = 0, f = 1;
    char c = getchar();
    while (c < '0' || c > '9')
    {
        if (c == '-')
            f = -1;
        c = getchar();
    }
    while (c >= '0' && c <= '9')
        x = x * 10 + c - '0', c = getchar();
    return x * f;
}

void write(int x)
{
    if (x < 0)
        putchar('-'), x = -x;
    if (x > 9)
        write(x / 10);
    putchar(x % 10 + '0');
}
int lowbit(int x)
{
    return x & (-x);
}
int qmi(int a, int b)//快速幂，求平方防溢出
{
    int res = 1;
    while (b)
    {
        if (b & 1)
            res = (res * a) % mod;
        a = (a * a) % mod;
        b >>= 1;
    }
    return res;
}
struct node
{
    int l, r;
    int sum;
    int lazy;//乘法lazy tag
    int flag;//优化操作 tag
} t[N << 2];
void pushup(int p)//同时更新flag
{
    t[p].sum = (t[p << 1].sum + t[p << 1 | 1].sum) % mod;
    if (t[p << 1].flag && t[p << 1 | 1].flag)
    {
        t[p].flag = 1;
    }
    else
    {
        t[p].flag = 0;
    }
}
void build(int p, int l, int r)
{
    t[p] = {l, r, 0, 0, 0};//初始化
    if (l == r)
    {
        t[p].sum = a[l];
        if (lowbit(a[l]) == a[l])
        {
            t[p].flag = 1;
        }
        else
        {
            t[p].flag = 0;
        }
        return;
    }
    int mid = l + r >> 1;
    build(p << 1, l, mid);
    build(p << 1 | 1, mid + 1, r);
    pushup(p);
}
void pushdown(int p)
{
    if (t[p].lazy)
    {
        t[p << 1].sum = (t[p << 1].sum * qmi(2, t[p].lazy)) % mod;
        t[p << 1 | 1].sum = (t[p << 1 | 1].sum * qmi(2, t[p].lazy)) % mod;
        t[p << 1].lazy += t[p].lazy;
        t[p << 1 | 1].lazy += t[p].lazy;
        t[p].lazy = 0;
    }
}
void modify(int p, int l, int r)
{
    if (t[p].l >= l && t[p].r <= r && t[p].flag)//在优化后进行区间操作
    {
        t[p].sum = (t[p].sum * 2) % mod;
        t[p].lazy++;
        return;
    }
    if (t[p].l == t[p].r)//暴力操作
    {
        t[p].sum += lowbit(t[p].sum);
        if (t[p].sum == lowbit(t[p].sum))
        {
            t[p].flag = 1;
        }
        return;
    }
    pushdown(p);
    if (t[p << 1].r >= l)
        modify(p << 1, l, r);
    if (t[p << 1 | 1].l <= r)
        modify(p << 1 | 1, l, r);
    pushup(p);
}
int query(int p, int l, int r)
{
    if (t[p].l >= l && t[p].r <= r)
    {
        return t[p].sum;
    }
    pushdown(p);
    int res = 0;
    if (t[p << 1].r >= l)
        res = (res + query(p << 1, l, r)) % mod;
    if (t[p << 1 | 1].l <= r)
        res = (res + query(p << 1 | 1, l, r)) % mod;
    return res;
}
void solve()
{

    int n;
    n = read();
    for (int i = 1; i <= n; i++)
        a[i] = read();
    build(1, 1, n);
    int q;
    q = read();
    while (q--)
    {
        int op, l, r;
        op = read(), l = read(), r = read();
        if (op == 1)
        {
            modify(1, l, r);
        }
        else if (op == 2)
        {
            write(query(1, l, r));
            puts("");
        }
    }
}

signed main()
{
    int T;
    T = read();
    while (T--)
    {
        solve();
    }
    return 0;
}