[luoguP1972] [SDOI2009]HH的项链（莫队 || 树状数组 || 主席树）

传送门

莫队基础题，适合我这种初学者。

莫队是离线算法，通常不带修改，时间复杂度为 O(n√n)

我们要先保证通过 [ l , r ] 求得 [ l , r + 1 ] , [ l , r - 1 ] , [ l - 1 , r ] , [ l + 1 , r ] 的效率是O(1)的

对于莫队的理解，移步远航休息栈

——代码

 #include <cmath>
 #include <cstdio>
 #include <iostream>
 #include <algorithm>

 int n, m, S, ans = ;
 int a[], ton[], anslist[];
 struct node
 {
     int l, r, id, num;
 }q[];

 inline int read()
 {
     int x = ;
     char ch = getchar();
     for(; !isdigit(ch); ch = getchar());
     for(; isdigit(ch); ch = getchar()) x = (x << ) + (x << ) + ch - '';
     return x;
 }

 inline bool cmp(node x, node y)
 {
     return x.id ^ y.id ? x.id < y.id : x.r < y.r;
 }

 int main()
 {
     int i, x, y;
     n = read();
     for(i = ; i <= n; i++) a[i] = read();
     m = read();
     for(i = ; i <= m; i++) q[i].l = read(), q[i].r = read(), q[i].num = i;
     S = sqrt(n);
     for(i = ; i <= m; i++) q[i].id = q[i].l / S + ;
     std::sort(q + , q + m + , cmp);
     x = q[].l, y = q[].l;
     ton[a[x]]++;
     for(i = ; i <= m; i++)
     {
         while(x < q[i].l)
         {
             ton[a[x]]--;
             if(!ton[a[x]]) ans--;
             x++;
         }
         while(x > q[i].l)
         {
             x--;
             if(!ton[a[x]]) ans++;
             ton[a[x]]++;
         }
         while(y > q[i].r)
         {
             ton[a[y]]--;
             if(!ton[a[y]]) ans--;
             y--;
         }
         while(y < q[i].r)
         {
             y++;
             if(!ton[a[y]]) ans++;
             ton[a[y]]++;
         }
         anslist[q[i].num] = ans;
     }
     for(i = ; i <= m; i++) printf("%d\n", anslist[i]);
     return ;
 }

代码量真是友善啊

还可以用离线用树状数组来做.

以下是hzwer的解法：

这题首先在线是没法做的，所以我们可以考虑离线算法

首先记录下每种颜色的下一种颜色所在的位置

将所有询问按照左端点进行排序

将所有颜色的第一个点x a[x]++

然后从左往右扫

扫到一个点x将a[next[x]]++

碰到一个询问l,r输出sum[r]-sum[l-1]

其中sum是a数组的前缀和

求前缀和可以用树状数组

——代码

 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <algorithm>

 const int MAXN = ;
 int n, m, max;
 int head[MAXN], next[MAXN], a[MAXN], ans[MAXN], c[];
 struct node
 {
     int l, r, id;
 }q[MAXN];

 inline int read()
 {
     int x = , f = ;
     char ch = getchar();
     for(; !isdigit(ch); ch = getchar()) if(ch == '-') f = -;
     for(; isdigit(ch); ch = getchar()) x = (x << ) + (x << ) + ch - '';
     return x * f;
 }

 inline int Max(int x, int y)
 {
     return x > y ? x : y;
 }

 inline void update(int x)
 {
     for(; x <= n; x += x & -x) c[x]++;
 }

 inline int query(int x)
 {
     int ret = ;
     for(; x; x -= x & -x) ret += c[x];
     return ret;
 }

 inline bool cmp(node x, node y)
 {
     return x.l < y.l;
 }

 int main()
 {
     int i, j;
     n = read();
     memset(head, -, sizeof(head));
     for(i = ; i <= n; i++) a[i] = read(), max = Max(max, a[i]);
     for(i = n; i; i--) next[i] = head[a[i]], head[a[i]] = i;
     for(i = ; i <= max; i++)
         if(head[i] ^ -)
             update(head[i]);
     m = read();
     for(i = ; i <= m; i++)
     {
         q[i].l = read();
         q[i].r = read();
         q[i].id = i;
     }
     std::sort(q + , q + m + , cmp);
     j = ;
     for(i = ; i <= n; i++)
     {
         while(q[j].l == i) ans[q[j].id] = query(q[j].r) - query(q[j].l - ), j++;
         if(next[i] ^ -) update(next[i]);
     }
     for(i = ; i <= m; i++) printf("%d\n", ans[i]);
     return ;
 }

主席树也是个好方法。

保存每个点的上一个和它颜色相同的点的位置（如果没有就是0）

然后以每个点的前驱为下标建主席数。

统计时只需要统计当前区间 [x,y] 中前驱小于 x 的点的个数

——代码

 #include <cstdio>
 #include <iostream>

 const int MAXN = ;
 int n, m, cnt;
 int a[MAXN], head[], pre[MAXN], root[MAXN], sum[MAXN * ], ls[MAXN * ], rs[MAXN * ];

 inline int read()
 {
     int x = , f = ;
     char ch = getchar();
     for(; !isdigit(ch); ch = getchar()) if(ch == '-') f = -;
     for(; isdigit(ch); ch = getchar()) x = (x << ) + (x << ) + ch - '';
     return x * f;
 }

 inline void update(int &now, int l, int r, int x)
 {
     ++cnt;
     sum[cnt] = sum[now] + ;
     ls[cnt] = ls[now];
     rs[cnt] = rs[now];
     now = cnt;
     if(l == r) return;
     int mid = (l + r) >> ;
     if(x <= mid) update(ls[now], l, mid, x);
     else update(rs[now], mid + , r, x);
 }

 inline int query(int x, int y, int l, int r, int k)
 {
     if(l == r) return sum[y] - sum[x];
     int mid = (l + r) >> ;
     if(k <= mid) return query(ls[x], ls[y], l, mid, k);
     else return query(rs[x], rs[y], mid + , r, k) + sum[ls[y]] - sum[ls[x]];
 }

 int main()
 {
     int i, x, y;
     n = read();
     for(i = ; i <= n; i++)
     {
         a[i] = read();
         pre[i] = head[a[i]];
         head[a[i]] = i;
     }
     for(i = ; i <= n; i++)
     {
         root[i] = root[i - ];
         update(root[i], , n, pre[i]);
     }
     m = read();
     for(i = ; i <= m; i++)
     {
         x = read();
         y = read();
         printf("%d\n", query(root[x - ], root[y], , n, x - ));
     }
     return ;
 }