CF 86D Powerful array 分块算法入门，n*sqrt(n)

分类： ACM_数据结构 Codeforces_problem 2013-08-18 19:31  465人阅读  评论(2)  收藏  举报

分块算法

简介：分块算法主要是把区间划分成sqrt(n)块，从而降低暴力的复杂度，

其实这算是一种优化的暴力吧，复杂度O(n*sqrt(n))

题意：给定一个数列：a[i]    (1<= i <= n)    K[j]表示 在区间 [l，r]中j出现的次数。

有t个查询，每个查询l，r，对区间内所有a[i]，求sigma（K[a[i]]^2*a[i]）

思路：离线+分块处理 

分块和离线处理：

将n个数分成sqrt(n)块，设每块有bsize个数， 并且我们计算出每个询问的左端点所在的块号(q[i].b = q[i].l/ bsize)。

对所有询问进行排序：

     先按块号排序(块号小的在前)，如果块号相等就要右端点排序(右端点小的在前)

解法：每次跟上次的询问区间比较，把多出来的减掉，把少的加上去。 当然第一个询问直接算。

如果一个数已经出现了x次，那么需要累加(2*x+1)*a[i]，因为(x+1)^2*a[i] = (x^2 +2*x + 1)*a[i]，

x^2*a[i]是出现x次的结果，(x+1)^2 * a[i]是出现x+1次的结果。就是暴力的处理。

复杂度分析：

  处理左端点的复杂度：

        对于相邻询问左端点的差值不会超过sqrt(n)， 所以t个询问的总体复杂度为O(t*sqrt(n))。

  处理右端点的复杂度：

        对于每个块内的几个查询，因为right是单调递增的，所以极限复杂度为O(n),  而且一共有sqrt(n)个块

        所以总体复杂度位O(n*sqrt(n));

       因此总的时间复杂度为O(t*sqrt(n)  +  n*sqrt(n))。

为什么选择sqrt(n)分块：

    我们从上面复杂度分析中可以得知， 左右断点的复杂度是独立的，

    当块数少了，左边复杂度加大，右边复杂度减少，  

    反之 当块数多了，左边复杂度减少，右边复杂度加大，

    块数选择sqrt(n)是为了总体复杂度的最小。  

代码：

[cpp]  view plain copy

1. #include <cstdio>  
2. #include <iostream>  
3. #include <algorithm>  
4. #include <cstring>  
5. #include <cmath>  
6. using namespace std;  
7. const int maxn = 200005;  
8. typedef long long LL;  
9. LL a[maxn], cnt[maxn * 5], ans[maxn], res;  
10. int L, R;  
11.   
12. struct node {  
13.     int l, r, b, id;  
14.     bool operator <(const node &t) const {  
15.         if (b == t.b)  
16.             return r < t.r;  
17.         return b < t.b;  
18.     }  
19. } q[maxn];  
20.   
21. LL query(int x, int y, int flag) {  
22.     if (flag) {  
23.         for (int i = x; i < L; i++) {  
24.             res += ((cnt[a[i]] << 1) + 1) * a[i];  
25.             cnt[a[i]]++;  
26.         }  
27.         for (int i = L; i < x; i++) {  
28.             cnt[a[i]]--;  
29.             res -= ((cnt[a[i]] << 1) + 1) * a[i];  
30.         }  
31.         for (int i = y + 1; i <= R; i++) {  
32.             cnt[a[i]]--;  
33.             res -= ((cnt[a[i]] << 1) + 1) * a[i];  
34.         }  
35.         for (int i = R + 1; i <= y; i++) {  
36.             res += ((cnt[a[i]] << 1) + 1) * a[i];  
37.             cnt[a[i]]++;  
38.         }  
39.   
40.     } else {  
41.         for (int i = x; i <= y; i++) {  
42.             res += ((cnt[a[i]] << 1) + 1) * a[i];  
43.             cnt[a[i]]++;  
44.         }  
45.     }  
46.     L = x, R = y;  
47.     return res;  
48. }  
49. int n, t;  
50. int main() {  
51.     int i;  
52.   
53.     scanf("%d%d", &n, &t);  
54.     for (i = 1; i <= n; i++)  
55.         scanf("%I64d", &a[i]);  
56.     int bsize = sqrt(n + 0.5);  
57.   
58.     for (i = 0; i < t; i++) {  
59.         scanf("%d%d", &q[i].l, &q[i].r);  
60.         q[i].b = q[i].l / bsize;  
61.         q[i].id = i;  
62.     }  
63.   
64.     sort(q, q + t);  
65.     memset(cnt, 0, sizeof(cnt));  
66.     res = 0;  
67.     for (i = 0; i < t; i++)  
68.         ans[q[i].id] = query(q[i].l, q[i].r, i);  
69.   
70.     for (i = 0; i < t; i++)  
71.         printf("%I64d\n", ans[i]);  
72.   
73.     return 0;  
74. }