城中分支

城中分支

题目描述

“城市处于建设中......”

预言之子的你获得了一个拥有 $n$ 个元素的数组。 天神赋予你 $q$ 次操作：

1. $Modify$，$l$，$r$，$x$------对于每个 $i$ $(l \leq i \leq r)$，将 $a_i$ 乘以 $x$ 。
2. $Query$，$l$，$r$------你需要回答 $\varphi(\prod_{i=l}^{r}{a_i})$ 取模 $10^9+7$，其中 $\varphi$ 表示欧拉函数。

正整数 $n$（表示为 $\varphi(n)$）的欧拉函数是满足 $\gcd(n,x)=1$ 的整数 $x$ $(1 \leq x \leq n)$ 的数量。

$\prod_{i=l}^{r}{a_i}$ 表示 $a_l \times a_{l+1} \times \cdots \times a_r$。

输入描述:

第一行包含两个整数 $n$ 和 $q$ $(1 \leq n \leq 4 \cdot 10^5 ,1 \leq q \leq 2 \cdot 10^5)$ — 数组中的元素数和查询数。

第二行包含 $n$ 个整数 $a_1, a_2, \ldots ,a_n$ $(1 \leq a_i \leq 300)$ — 数组 $a$ 的元素。

接下来是 $q$ 行以语句中给出的格式描述查询。

$Modify$，$l$，$r$，$x$ $(1 \leq l \leq r \leq n, 1\leq x \leq 300)$ —表示修改操作。

$Query$，$l$，$r$ $(1 \leq l \leq r \leq n)$ ——表示对欧拉函数值的查询操作。

数据保证至少有一个 $Query$ 查询。

输出描述:

对于每个 $Query$ 查询，打印其答案对 $10^9+7$ 取模的结果。

示例1

输入

4 4
5 9 1 2
Query 3 3
Query 3 4
Modify 4 4 3
Query 4 4

输出

1
1
2

示例2

输入

1 1
4
Query 1 1

输出

2

 

解题思路

  代码巨长巨难写，卡了快 3 个小时，不是 TLE 就是 MLE。

  首先有欧拉函数公式 $\varphi(x) = x \left(1 - \frac{1}{P_0}\right)\left(1 - \frac{1}{P_1}\right) \cdots \left(1 - \frac{1}{P_k}\right)$，其中 $x = P_{0}^{\alpha_{0}}P_{1}^{\alpha_{1}} \cdots P_{k}^{\alpha_{k}}$。因此有 $\varphi(x) = P_0^{\alpha_0} \left(1 - \frac{1}{P_0}\right) \cdot P_1^{\alpha_1} \left(1 - \frac{1}{P_1}\right) \cdots \cdot P_k^{\alpha_k} \left(1 - \frac{1}{P_k}\right) = \varphi(P_{0}^{\alpha_0}) \varphi(P_{1}^{\alpha_1}) \cdots \varphi(P_{k}^{\alpha_k})$。

  显然需要用到线段树，但我们既不可以直接维护区间的乘积（显然爆 long long），又不可以对乘积取模（否则求不了欧拉函数）。注意到 $a_i$ 和 $x$ 都不超过 $300$，而 $300$ 内的质数只有 $62$ 个，意味着乘积的结果均可以表示成 $P_{0}^{\alpha_{0}}P_{1}^{\alpha_{1}} \cdots P_{61}^{\alpha_{61}}$，因此我们可以转向去维护乘积结果的各个质因子的数量即 $\alpha_{i}$。

  定义线段树节点信息：

struct Node {
    int l, r;
    array<LL, 62> s, sum;
};

  当需要给节点维护的整个区间乘上 $x = P_{0}^{\alpha_{0}}P_{1}^{\alpha_{1}} \cdots P_{61}^{\alpha_{61}}$ 时，只需更新 $s_i \gets s_i + \alpha_{i}(r-l+1)$，$\text{sum}_i \gets \text{sum}_i + \alpha_i$ $(0 \leq i < 62)$（$\text{sum}$ 是懒标记）。

  查询时，我们累加询问区间内每个质因子的次数，用大小为 $62$ 的数组 $s$ 表示。乘积的欧拉函数就是 $\prod\limits_{i=0}^{61} [s_i > 0] \, P_i^{s_i} \left(1 - \frac{1}{P_i} \right)$。

  上述做法的时间复杂度为 $O\left( n \log{A} + q\log{n}(\log{A} + \pi(A)\log{(q\log{A})}) \right)$，空间复杂度为 $O(n \pi(A))$。然而实际上线段树所需要的内存空间为 1k+ MB！上述做法肯定过不了。

  用不了线段树然后我就投机取巧用分块，结果空间是变小了但 TLE。做法和上面类似，每个块维护各个质因子的数量，具体做法就不详述了。分块的时间复杂度为 $O\left( n \log{A} + q\sqrt{n}(\log{A} + \pi(A)\log{(q\log{A})}) \right)$，空间复杂度为 $O(n \pi(A))$ 但常数比上面的小非常多。

  分块做法 TLE 代码如下：

查看代码

#include <bits/stdc++.h>
using namespace std;

typedef long long LL;

const int N = 4e5 + 5, M = 305, B = 640, mod = 1e9 + 7;

int a[N][62];
int prime[M], mp[M], minp[M], cnt;
bool vis[M];
int id[N];
LL s[B][M], sum[B][M], c[M];

void get_prime(int n) {
    for (int i = 2; i <= n; i++) {
        if (!vis[i]) {
            prime[cnt] = i;
            mp[i] = cnt++;
            minp[i] = i;
        }
        for (int j = 0; prime[j] * i <= n; j++) {
            vis[prime[j] * i] = true;
            minp[prime[j] * i] = prime[j];
            if (i % prime[j] == 0) break;
        }
    }
}

int qmi(int a, LL k) {
    int ret = 1;
    while (k) {
        if (k & 1) ret = 1ll * ret * a % mod;
        a = 1ll * a * a % mod;
        k >>= 1;
    }
    return ret;
}

void modify(int l, int r, int x) {
    if (id[l] == id[r]) {
        for (int i = l; i <= r; i++) {
            int t = x;
            while (t > 1) {
                a[i][mp[minp[t]]]++;
                s[id[i]][mp[minp[t]]]++;
                t /= minp[t];
            }
        }
        
    }
    else {
        for (int i = l; id[i] == id[l]; i++) {
            int t = x;
            while (t > 1) {
                a[i][mp[minp[t]]]++;
                s[id[i]][mp[minp[t]]]++;
                t /= minp[t];
            }
        }
        for (int i = r; id[i] == id[r]; i--) {
            int t = x;
            while (t > 1) {
                a[i][mp[minp[t]]]++;
                s[id[i]][mp[minp[t]]]++;
                t /= minp[t];
            }
        }
        for (int i = id[l] + 1; i < id[r]; i++) {
            int t = x;
            while (t > 1) {
                s[i][mp[minp[t]]] += B;
                sum[i][mp[minp[t]]]++;
                t /= minp[t];
            }
        }
    }
}

int query(int l, int r) {
    memset(c, 0, sizeof(c));
    if (id[l] == id[r]) {
        for (int i = l; i <= r; i++) {
            for (int j = 0; j < cnt; j++) {
                c[j] += a[i][j] + sum[id[i]][j];
            }
        }
    }
    else {
        for (int i = l; id[i] == id[l]; i++) {
            for (int j = 0; j < cnt; j++) {
                c[j] += a[i][j] + sum[id[i]][j];
            }
        }
        for (int i = r; id[i] == id[r]; i--) {
            for (int j = 0; j < cnt; j++) {
                c[j] += a[i][j] + sum[id[i]][j];
            }
        }
        for (int i = id[l] + 1; i < id[r]; i++) {
            for (int j = 0; j < cnt; j++) {
                c[j] += s[i][j];
            }
        }
    }
    int ret = 1;
    for (int i = 0; i < cnt; i++) {
        if (c[i]) ret = ret * (prime[i] - 1ll) % mod * qmi(prime[i], c[i] - 1) % mod;
    }
    return ret;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, m;
    cin >> n >> m;
    get_prime(M - 1);
    for (int i = 1; i <= n; i++) {
        int x;
        cin >> x;
        id[i] = (i - 1) / B + 1;
        while (x > 1) {
            a[i][mp[minp[x]]]++;
            s[id[i]][mp[minp[x]]]++;
            x /= minp[x];
        }
    }
    while (m--) {
        string s;
        cin >> s;
        if (s[0] == 'M') {
            int l, r, x;
            cin >> l >> r >> x;
            modify(l, r, x);
        }
        else {
            int l, r;
            cin >> l >> r;
            cout << query(l, r) << '\n';
        }
    }
    
    return 0;
}

  下面给出正解了，还是用到线段树。细想一下，最开始的线段树做法会 MLE，正是因为我们给每个节点都开了大小为 $62$ 的数组去统计各个质因子的数量，而我们有必要去记录质因子的数量吗？回想欧拉函数 $\varphi(x) = x \left(1 - \frac{1}{P_0}\right)\left(1 - \frac{1}{P_1}\right) \cdots \left(1 - \frac{1}{P_k}\right)$，我们只要分别知道对应区间乘积的结果（可以取模），以及乘积结果（不取模）所含有的质因子，就可以计算欧拉函数。可以发现我们并不需要统计各个质因子的数量，只需统计出现了哪些质因子即可，这个可以用一个 long long 变量来状态压缩统计。

  为此重新定义线段树节点信息：

struct Node {
    int l, r;
    int p, prod;
    LL s, sum;
};

  其中 $p$ 是区间乘积取模后的结果，$\text{prod}$ 是对应的区间乘懒标记。$s$ 是状态压缩表示区间乘积（没取模）包含的质因子，$\text{sum}$ 是对应的区间加懒标记。节点更新以及懒标记下传请参考代码，这里就不过多赘述了。

  AC 代码如下，时间复杂度为 $O(n \log{A} + q (\log{n} + \pi(A)))$，空间复杂度为 $O(n)$：

#include <bits/stdc++.h>
using namespace std;

typedef long long LL;

const int N = 4e5 + 5, M = 305, B = 640, mod = 1e9 + 7;

int a[N][62];
int prime[M], mp[M], minp[M], cnt;
bool vis[M];
int id[N];
LL s[B][M], sum[B][M], c[M];

void get_prime(int n) {
    for (int i = 2; i <= n; i++) {
        if (!vis[i]) {
            prime[cnt] = i;
            mp[i] = cnt++;
            minp[i] = i;
        }
        for (int j = 0; prime[j] * i <= n; j++) {
            vis[prime[j] * i] = true;
            minp[prime[j] * i] = prime[j];
            if (i % prime[j] == 0) break;
        }
    }
}

int qmi(int a, LL k) {
    int ret = 1;
    while (k) {
        if (k & 1) ret = 1ll * ret * a % mod;
        a = 1ll * a * a % mod;
        k >>= 1;
    }
    return ret;
}

void modify(int l, int r, int x) {
    if (id[l] == id[r]) {
        for (int i = l; i <= r; i++) {
            int t = x;
            while (t > 1) {
                a[i][mp[minp[t]]]++;
                s[id[i]][mp[minp[t]]]++;
                t /= minp[t];
            }
        }
        
    }
    else {
        for (int i = l; id[i] == id[l]; i++) {
            int t = x;
            while (t > 1) {
                a[i][mp[minp[t]]]++;
                s[id[i]][mp[minp[t]]]++;
                t /= minp[t];
            }
        }
        for (int i = r; id[i] == id[r]; i--) {
            int t = x;
            while (t > 1) {
                a[i][mp[minp[t]]]++;
                s[id[i]][mp[minp[t]]]++;
                t /= minp[t];
            }
        }
        for (int i = id[l] + 1; i < id[r]; i++) {
            int t = x;
            while (t > 1) {
                s[i][mp[minp[t]]] += B;
                sum[i][mp[minp[t]]]++;
                t /= minp[t];
            }
        }
    }
}

int query(int l, int r) {
    memset(c, 0, sizeof(c));
    if (id[l] == id[r]) {
        for (int i = l; i <= r; i++) {
            for (int j = 0; j < cnt; j++) {
                c[j] += a[i][j] + sum[id[i]][j];
            }
        }
    }
    else {
        for (int i = l; id[i] == id[l]; i++) {
            for (int j = 0; j < cnt; j++) {
                c[j] += a[i][j] + sum[id[i]][j];
            }
        }
        for (int i = r; id[i] == id[r]; i--) {
            for (int j = 0; j < cnt; j++) {
                c[j] += a[i][j] + sum[id[i]][j];
            }
        }
        for (int i = id[l] + 1; i < id[r]; i++) {
            for (int j = 0; j < cnt; j++) {
                c[j] += s[i][j];
            }
        }
    }
    int ret = 1;
    for (int i = 0; i < cnt; i++) {
        if (c[i]) ret = ret * (prime[i] - 1ll) % mod * qmi(prime[i], c[i] - 1) % mod;
    }
    return ret;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, m;
    cin >> n >> m;
    get_prime(M - 1);
    for (int i = 1; i <= n; i++) {
        int x;
        cin >> x;
        id[i] = (i - 1) / B + 1;
        while (x > 1) {
            a[i][mp[minp[x]]]++;
            s[id[i]][mp[minp[x]]]++;
            x /= minp[x];
        }
    }
    while (m--) {
        string s;
        cin >> s;
        if (s[0] == 'M') {
            int l, r, x;
            cin >> l >> r >> x;
            modify(l, r, x);
        }
        else {
            int l, r;
            cin >> l >> r;
            cout << query(l, r) << '\n';
        }
    }
    
    return 0;
}

 

参考资料

  沈阳化工大学第十一届程序设计竞赛专业组题解：https://ac.nowcoder.com/discuss/1408217

  thisislike_fan 提交的代码：https://ac.nowcoder.com/acm/contest/view-submission?submissionId=71790420