洛谷P5071 此时此刻的光辉

2s512M。

解：先分解质因数。考虑按照质因数大小是否大于√分类。

大于的就是一个数颜色个数，莫队即可n√m。

小于的直接枚举质因数做前缀和然后O(1)查询。总时间复杂度n(√m + σ(√V))。

发现我们T飞了，发现莫队的复杂度较优，而处理小于√V的质因数较劣。我们平衡一下。

把界调整到1000。这样比lm大的至多两个，莫队常数*2。而后半部分的复杂度就变成了nσ(³√V)，可以通过本题。

#include <bits/stdc++.h>

const int N = 100010, MO = 19260817;

inline char gc() {
    static char *p1, *p2, s[N];
    if(p1 == p2) p2 = (p1 = s) + fread(s, 1, N, stdin);
    return (p1 == p2) ? EOF : *p1++;
}

template <class T> inline void read(T &x) {
    x = 0;
    register char c(gc());
    while(c < '0' || c > '9') {
        c = gc();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - 48;
        c = gc();
    }
    return;
}

int ex[N], p[N], a[N], lc[N], rc[N], fr[N], top, X[N * 2], xx, inv[N], bin[N], Ans, ans[N], sum[N], exx[N];
bool vis[N];
std::vector<int> v[N], v2[N];

struct Node {
    int l, r, id;
    inline bool operator < (const Node &w) const {
        if(fr[l] != fr[w.l]) return l < w.l;
        return r < w.r;
    }
}node[N];

inline void getp(int n) {
    for(register int i = 2; i <= n; i++) {
        if(!vis[i]) p[++top] = i;
        for(int j = 1; j <= top && i * p[j] <= n; j++) {
            vis[i * p[j]] = 1;
            if(i % p[j] == 0) break;
        }
    }
    return;
}

inline void add(int y) {
    if(ex[y]) {
        int x(ex[y]);
        if(bin[x]) {
            Ans = 1ll * Ans * inv[bin[x] + 1] % MO;
        }
        ++bin[x];
        Ans = 1ll * Ans * (bin[x] + 1) % MO;
    }
    if(exx[y]) {
        int x(exx[y]);
        if(bin[x]) {
            Ans = 1ll * Ans * inv[bin[x] + 1] % MO;
        }
        ++bin[x];
        Ans = 1ll * Ans * (bin[x] + 1) % MO;
    }
    return;
}

inline void del(int y) {
    if(ex[y]) {
        int x(ex[y]);
        Ans = 1ll * Ans * inv[bin[x] + 1] % MO;
        --bin[x];
        if(bin[x]) {
            Ans = 1ll * Ans * (bin[x] + 1) % MO;
        }
    }
    if(exx[y]) {
        int x(exx[y]);
        Ans = 1ll * Ans * inv[bin[x] + 1] % MO;
        --bin[x];
        if(bin[x]) {
            Ans = 1ll * Ans * (bin[x] + 1) % MO;
        }
    }
    return;
}

inline void solve(int x) {
    printf("div : %d 
", x);
    for(int i = 1; i <= top; i++) {
        if(x % p[i]) continue;
        while(x % p[i] == 0) {
            printf("%d ", p[i]);
            x /= p[i];
        }
    }
    if(x > 1) printf("%d ", x);
    puts("");
    return;
}

int main() {
    getp(31623);

    register int n, m, lm(1000);
    //scanf("%d%d", &n, &m);
    read(n), read(m);
    int T = n / sqrt(m);
    for(register int i(1); i <= n; ++i) {
        //scanf("%d", &a[i]);
        read(a[i]);
        fr[i] = (i - 1) / T + 1;
        register int x(a[i]), j(1);
        for(; p[j] <= lm && p[j] <= x; ++j) {
            register int cnt(0);
            while(x % p[j] == 0) {
                x /= p[j];
                ++cnt;
            }
            if(cnt) {
                v[j].push_back(i);
                v2[j].push_back(cnt);
            }
        }
        if(x == 1) continue;
        for(; j <= top; j++) {
            if(x % p[j] == 0) {
                exx[i] = p[j];
                X[++xx] = p[j];
                x /= p[j];
                break;
            }
        }
        if(x > 1) {
            ex[i] = x;
            X[++xx] = x;
        }
    }

    std::sort(X + 1, X + xx + 1);
    xx = std::unique(X + 1, X + xx + 1) - X - 1;
    for(register int i(1); i <= n; ++i) {
        //printf("i = %d : %d %d 
", i, ex[i], exx[i]);
        if(ex[i]) {
            ex[i] = std::lower_bound(X + 1, X + xx + 1, ex[i]) - X;
        }
        if(exx[i]) {
            exx[i] = std::lower_bound(X + 1, X + xx + 1, exx[i]) - X;
        }
    }

    for(register int i(1); i <= m; ++i) {
        //scanf("%d%d", &node[i].l, &node[i].r);
        read(node[i].l); read(node[i].r);
        node[i].id = i;
    }
    inv[0] = inv[1] = 1;
    for(register int i(2); i <= n + 1; ++i) {
        inv[i] = 1ll * inv[MO % i] * (MO - MO / i) % MO;
    }

    for(register int i(1); i <= fr[n]; ++i) {
        lc[i] = rc[i - 1] + 1;
        rc[i] = lc[i] + T - 1;
        if(i == fr[n]) rc[i] = n;
    }

    std::sort(node + 1, node + m + 1);

    Ans = 1;
    add(1);
    int l = 1, r = 1;
    for(register int i = 1; i <= m; i++) {
        while(r < node[i].r) {
            add(++r);
        }
        while(node[i].l < l) {
            add(--l);
        }
        while(node[i].r < r) {
            del(r--);
        }
        while(l < node[i].l) {
            del(l++);
        }
        ans[node[i].id] = Ans;
        //printf("ans %d = %d 
", node[i].id, Ans);
    }

    /// step 2

    for(register int i(1); p[i] <= lm; ++i) {
        int LEN(v[i].size()), p(0);
        for(register int j(1); j <= n; ++j) {
            sum[j] = sum[j - 1];
            if(p < LEN && v[i][p] == j) {
                sum[j] += v2[i][p++];
            }
        }
        for(register int j(1); j <= m; ++j) {
            int x = sum[node[j].r] - sum[node[j].l - 1];
            ans[node[j].id] = 1ll * ans[node[j].id] * (x + 1) % MO;
        }
    }

    for(register int i(1); i <= m; ++i) {
        printf("%d
", ans[i]);
    }

    return 0;
}