[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 = 1;
int a[50001], ton[1000001], anslist[200001];
struct node
{
    int l, r, id, num;
}q[200001];

inline int read()
{
    int x = 0;
    char ch = getchar();
    for(; !isdigit(ch); ch = getchar());
    for(; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + ch - '0';
    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 = 1; i <= n; i++) a[i] = read();
    m = read();
    for(i = 1; i <= m; i++) q[i].l = read(), q[i].r = read(), q[i].num = i;
    S = sqrt(n);
    for(i = 1; i <= m; i++) q[i].id = q[i].l / S + 1;
    std::sort(q + 1, q + m + 1, cmp);
    x = q[1].l, y = q[1].l;
    ton[a[x]]++;
    for(i = 1; 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 = 1; i <= m; i++) printf("%d\n", anslist[i]);
    return 0;
}

代码量真是友善啊

 

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

以下是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 = 50001;
int n, m, max;
int head[MAXN], next[MAXN], a[MAXN], ans[MAXN], c[1000001];
struct node
{
    int l, r, id;
}q[MAXN];

inline int read()
{
    int x = 0, f = 1;
    char ch = getchar();
    for(; !isdigit(ch); ch = getchar()) if(ch == '-') f = -1;
    for(; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + ch - '0';
    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 = 0;
    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, -1, sizeof(head));
    for(i = 1; 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 = 1; i <= max; i++)
        if(head[i] ^ -1)
            update(head[i]);
    m = read();
    for(i = 1; i <= m; i++)
    {
        q[i].l = read();
        q[i].r = read();
        q[i].id = i;
    }
    std::sort(q + 1, q + m + 1, cmp);
    j = 1;
    for(i = 1; i <= n; i++)
    {
        while(q[j].l == i) ans[q[j].id] = query(q[j].r) - query(q[j].l - 1), j++;
        if(next[i] ^ -1) update(next[i]);
    }
    for(i = 1; i <= m; i++) printf("%d\n", ans[i]);
    return 0;
}

 

 

主席树也是个好方法。

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

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

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

 

——代码

#include <cstdio>
#include <iostream>

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

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

inline void update(int &now, int l, int r, int x)
{
    ++cnt;
    sum[cnt] = sum[now] + 1;
    ls[cnt] = ls[now];
    rs[cnt] = rs[now];
    now = cnt;
    if(l == r) return;
    int mid = (l + r) >> 1;
    if(x <= mid) update(ls[now], l, mid, x);
    else update(rs[now], mid + 1, 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) >> 1;
    if(k <= mid) return query(ls[x], ls[y], l, mid, k);
    else return query(rs[x], rs[y], mid + 1, r, k) + sum[ls[y]] - sum[ls[x]];
}

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