【CodeForces】86D Powerful array

题意：

给出一个数列1~n。

令ks表示s的出现次数。

询问区间[x,y]中，s * ks^2之和。

将数列分成sqrt(n)块，不在区间范围内的暴力，但是在区间范围内的无法常数时间统计。

 

以下算法及证明摘自CodeForces...

Let's sort the query intervals according to the following rule: first come the intervals with the left ends in Q_1, then the intervals with the left ends in Q_2, and so on. And if the left ends of the two queries belong to the same part, then the interval with the more left right end is assumed to be smaller.
In order to prove the stated asymptotic behavior we will follow the steps of the left and the right ends independently. We note that the left ends that belong to the same Q_i make <= n / p steps, and transition to Q_{i+1} costs no more than 2 * n / p steps. Therefore the left ends make <= n/p * n + 2*n steps (the second summand is O(n), and it's negligible).
The right ends in the common group move only to the right, and this proves <= n * p steps (during the whole process) estimate. We will estimate the transition to the next Q_i at no more than n steps, so overall we get <= 2 * n * p steps.
Thus, the total number of steps is no more than (n / p * n + 2 * n * p). Now we choose p = sqrt(n) which proves the statement.

#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#define MAXN 200010
#define EPS 1e-8
typedef long long LL;
using namespace std;
LL res, ans[MAXN];
int n, block, L, R;
int cnt[MAXN * 5], a[MAXN];
struct node {
    int x, y, left, pos;
};
node p[MAXN];
inline bool cmp(node a, node b) {
    if (a.left == b.left)
        return a.y < b.y;
    return a.left < b.left;
}
void Query(int x, int y, int flag) {
    int i;
    if (flag) {
        for (i = L - 1; i >= x; i--) {
            cnt[a[i]]++;
            res += ((cnt[a[i]] << 1) - 1) * (LL) a[i];
        }
        for (i = L; i < x; i++) {
            res -= ((cnt[a[i]] << 1) - 1) * (LL) a[i];
            cnt[a[i]]--;
        }
        for (i = R + 1; i <= y; i++) {
            cnt[a[i]]++;
            res += ((cnt[a[i]] << 1) - 1) * (LL) a[i];
        }
        for (i = R; i > y; i--) {
            res -= ((cnt[a[i]] << 1) - 1) * (LL) a[i];
            cnt[a[i]]--;
        }
    } else {
        for (i = x; i <= y; i++) {
            cnt[a[i]]++;
            res += ((cnt[a[i]] << 1) - 1) * (LL) a[i];
        }
    }
    L = x;
    R = y;
}
int main() {
    int q, i;
    while (~scanf("%d%d", &n, &q)) {
        memset(cnt, 0, sizeof(cnt));
        block = (int) (ceil(sqrt((double) n)) + EPS);
        for (i = 1; i <= n; i++)
            scanf("%d", &a[i]);
        for (i = 0; i < q; i++) {
            scanf("%d%d", &p[i].x, &p[i].y);
            p[i].left = p[i].x / block;
            p[i].pos = i;
        }
        sort(p, p + q, cmp);
        for (res = i = 0; i < q; i++) {
            Query(p[i].x, p[i].y, i);
            ans[p[i].pos] = res;
        }
        for (i = 0; i < q; i++)
            printf("%I64d\n", ans[i]);
    }
    return 0;
}