D. Yaroslav and Divisors顺序统计+树状数组

题意：
给你一组$n$n个数字，这些数字是$1~n$1 n的一个排列。现在有很多个询问，询问给定一个区间，问区间内有多少个整除对。
思路：
设$sum[i]$sum[i]为从1到i的所有整除对数量。对于区间$[l,r]$[l,r]，我们知道，区间$[l,r]$[l,r]的整除对数量是$sum[r]-sum[l-1]$sum[r]−sum[l−1]再减去左端点在$[1,l-1]$[1,l−1]，右端点在$[l,r]$[l,r]内的整除对，所以可以离线做。设$sum[r]-sum[l-1]=x$sum[r]−sum[l−1]=x，剩下的是$y$y，求的就是$x-y$x−y。
对于一个数i，在区间$[1,n]$[1,n]内有$n/i$n/i个与i组成整除对的数。可以利用这个性质来计算$y$y，按顺序枚举$i$i，对于区间$[l,r]$[l,r]的询问，当$l=i$l=i时，$sum[r]-sum[l-1]$sum[r]−sum[l−1]就是$y$y的值。然后再把$sum$sum内$i$i的倍数加1，因为i也应该算在$x$x内，不在$y$y内。对于$x$x，则当$r=i$r=i时，$sum[r]-sum[l-1]$sum[r]−sum[l−1]就是$x$x。
用树状数组或线段树维护$sum$sum，复杂度可以优化到$nlog_{2}^{n}$nlog2n​。

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 2e5 + 10;
int n, m, a[N], pos[N];
ll ans[N];
struct node {
    int l, r, id;
} q1[N], q2[N];
struct BinaryIndexedTree {
    ll c[N], n;
    inline void init() {
        memset(c, 0, sizeof(c));
    }
    inline void update(int x, int k) {
        while (x <= n)
            c[x] += k, x += (x & -x);
    }
    inline ll getsum(int x) {
        ll ans = 0;
        while (x > 0)
            ans += c[x], x -= (x & -x);
        return ans;
    }
} BIT;
int main() {
    scanf("%d%d", &n, &m);
    BIT.n = n;
    for(int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
        pos[a[i]] = i;
    }
    for(int i = 1; i <= m; i++) {
        scanf("%d%d", &q1[i].l, &q1[i].r);
        q1[i].id = i;
        q2[i] = q1[i];
    }
    sort(q1 + 1, q1 + m + 1, [](const node & a, const node & b) {
        if(a.l == b.l)
            return a.r < b.r;
        return a.l < b.l;
    });
    sort(q2 + 1, q2 + m + 1, [](const node & a, const node & b) {
        if(a.r == b.r)
            return a.l < b.l;
        return a.r < b.r;
    });
    for(int j = 1, k = 1, i = 1; i <= n; i++) {
        while(q1[j].l == i && j <= m) {
            ans[q1[j].id] -= BIT.getsum(q1[j].r) - BIT.getsum(q1[j].l - 1);
            j++;
        }
        for(int v = 1; v * a[i] <= n; v++)
            BIT.update(pos[a[i] * v], 1);
        while(q2[k].r == i && k <= m) {
            ans[q2[k].id] += BIT.getsum(q2[k].r) - BIT.getsum(q2[k].l - 1);
            k++;
        }
    }
    for(int i = 1; i <= m; i++)
        printf("%I64d\n", ans[i]);
    return 0;
}

标签：ll,树状,int,sum,yyy,Yaroslav,区间,整除,Divisors
来源： https://blog.csdn.net/Endeavor_G/article/details/100662685