[ural 2124]. Algebra on Segment

Posted 2020-11-30 psimonw

题意

给出一个模(p)（(p)是素数）意义下的序列，支持两种操作：

1. 区间乘一个数；
2. 询问一个区间的元素构成的群的大小。

保证序列中的数时时刻刻不为(0)。

题解

一道好题……sb了好久。
第一个想法显然是先找到一个原根(g)，再取指标进行运算。
然后对于一个区间(g ^ {k_l}, g ^ {k_{l + 1}}, ldots, g ^ {k_r})，生成群的生成元(omega)为(g ^ {(gcd{k_l, k_{l + 1}, ldots, k_r, p - 1})})，则群的大小为(frac{p - 1}{ind_g(omega)})。
看这个(gcd)，因为要区间修改，所以要维护原序列和原序列的差分两个数组，因为
[ gcd(x_1, x_2, ldots, x_n) = gcd(x_1, x_2 - x_1, ldots, x_n - x_{n - 1}) ]
这样便把区间修改变成单点修改。
复杂度是(mathcal O((n + q) sqrt {(n + q) p} + q log ^ 2 n))，因为要bsgs求指标（我tmbsgs块大小还写挂了）。
然而这样是过不了的。那咋整啊？
XZA说指标的信息有冗余，实际上只需要求阶即可（求阶是(mathcal O(log ^ 2 p))的）。然而当时并没有理解这句话的意思，尽管感性理解好像是这回事。
考虑直接用阶做。
假设我们已经知道了区间([l, r])中每个元素的阶，那么如何求其生成群的大小？考虑两两合并。
对于一个阶为(a)的元素和一个阶为(b)的元素，其生成的群可分别表示为(<g ^ {frac{p - 1}{a}}>, <g ^ {frac{p - 1}{b}}>)。
那么合并之后，群可表示为(<g ^ {gcd{(frac{p - 1}{a}}, frac{p - 1}{b})}>)。则新的群的大小为(frac{p - 1}{gcd{(frac{p - 1}{a}}, frac{p - 1}{b})})。
（这其中用到了一个很基础的定理：循环群的大小等于其生成元的阶。）
简单运算一下，发现合并后群的大小就等于( ext{lcm} (a, b))。所以，这要求维护一个区间( ext{lcm})。但是区间( ext{lcm})也许并没有带区间乘的优秀做法。
实际上，我们可以维护一个商分，即(a_i' = a_i * {a_{i - 1}} ^ {-1})。这样区间乘就变成了单点乘。
根据这题的询问是群，则((a_l, a_{l + 1} * {a_l} ^ {-1}, ldots, a_r * {a_{r - 1}} ^ {-1}))形成的群和((a_l, a_{l + 1}, ldots, a_r))形成的群并没有区别，所以维护商分完全可行。
因此，大概只需要一棵线段树维护原序列，一棵线段树维护商分序列的每个元素的阶的区间( ext{lcm})即可。
复杂度(mathcal O((n + q) log ^ 2 n))。常数极大。（以上(log n)和(log p)混用了，明白就好）

#include <bits/stdc++.h>
#define fi first
#define se second
using namespace std;
typedef pair <int, int> pii;
const int N = 1e5 + 5;
int mod, _mod, n, q;
int a[N], g[N << 2], v[N << 2];
vector <pii> pf;
int lcm (int x, int y) {
    return x / __gcd(x, y) * y;
}
int power (int x, int y, int mod) {
    int ret = 1;
    for ( ; y; y >>= 1, x = 1ll * x * x % mod) {
        if (y & 1) {
            ret = 1ll * ret * x % mod;
        }
    }
    return ret;
}
void factorize (int x) {
    pf.clear();
    int t = sqrt(x + 1);
    for (int i = 2, c; i <= t; ++i) {
        if (x % i == 0) {
            c = 0;
            for ( ; x % i == 0; x /= i, ++c);
            pf.push_back(make_pair(i, c));
        }
    }
    if (x > 1) {
        pf.push_back(make_pair(x, 1));
    }
}
int ord (int x) {
    int ret = _mod;
    for (auto q : pf) {
        for (int i = 1; i <= q.se; ++i) {
            if (power(x, ret / q.fi, mod) == 1) {
                ret /= q.fi;
            } else {
                break;
            }
        }
    }
    return ret;
}
void build (int o, int l, int r) {
    v[o] = 1;
    if (l == r) {
        g[o] = v[o] = a[l];
        if (l) {
            g[o] = 1ll * g[o] * power(a[l - 1], mod - 2, mod) % mod;
        }
        g[o] = ord(g[o]);
        return;
    }
    int mid = (l + r) >> 1;
    build(o << 1, l, mid), build(o << 1 | 1, mid + 1, r);
    g[o] = lcm(g[o << 1], g[o << 1 | 1]);
}
void pushdown (int o) {
    if (v[o] != 1) {
        v[o << 1] = (1ll * v[o << 1] * v[o]) % mod;
        v[o << 1 | 1] = (1ll * v[o << 1 | 1] * v[o]) % mod;
        v[o] = 1;
    }
}
int query (int o, int l, int r, int x) {
    if (l == r) {
        return v[o];
    }
    pushdown(o);
    int mid = (l + r) >> 1;
    if (x <= mid) {
        return query(o << 1, l, mid, x);
    } else {
        return query(o << 1 | 1, mid + 1, r, x);
    }
}
void modify (int o, int l, int r, int x, int v) {
    if (l == r) {
        g[o] = 1ll * query(1, 1, n, l) * power(query(1, 1, n, l - 1), mod - 2, mod) % mod;
        g[o] = ord(g[o]);
        return;
    }
    int mid = (l + r) >> 1;
    if (x <= mid) {
        modify(o << 1, l, mid, x, v);
    } else {
        modify(o << 1 | 1, mid + 1, r, x, v);
    }
    g[o] = lcm(g[o << 1], g[o << 1 | 1]);
}
void modify (int o, int l, int r, int x, int y, int z) {
    if (x <= l && r <= y) {
        v[o] = 1ll * v[o] * z % mod;
        return;
    }
    pushdown(o);
    int mid = (l + r) >> 1;
    if (x <= mid) {
        modify(o << 1, l, mid, x, y, z);
    }
    if (y > mid) {
        modify(o << 1 | 1, mid + 1, r, x, y, z);
    }
}
int query (int o, int l, int r, int x, int y) {
    if (x <= l && r <= y) {
        return g[o];
    }
    int mid = (l + r) >> 1, ret = 1;
    if (x <= mid) {
        ret = lcm(ret, query(o << 1, l, mid, x, y));
    }
    if (y > mid) {
        ret = lcm(ret, query(o << 1 | 1, mid + 1, r, x, y));
    }
    return ret;
}
int read () {
    int x = 0; char ch = getchar();
    for ( ; !isdigit(ch); ch = getchar());
    for ( ; isdigit(ch); ch = getchar()) {
        x = x * 10 + ch - '0';
    }
    return x;
}
void write (int x) {
    if (x >= 10) {
        write(x / 10);
    }
    putchar('0' + x % 10);
}
int main () {
    mod = read(), n = read(), q = read();
    factorize(_mod = mod - 1);
    for (int i = 1; i <= n; ++i) {
        a[i] = read();
    }
    build(1, 1, n);
    for (int i = 1, o, l, r, x; i <= q; ++i) {
        o = read(), l = read(), r = read();
        if (o == 1) {
            x = read();
            modify(1, 1, n, l, r, x);
            modify(1, 1, n, l, x);
            if (r < n) {
                modify(1, 1, n, r + 1, -x);
            }
        } else {
            x = ord(query(1, 1, n, l));
            if (l < r) {
                x = lcm(x, query(1, 1, n, l + 1, r));
            }
            write(x), putchar('
');
        }
    }
    return 0;
}