前言

• 對於一個維護區間的問題，最暴力的方法就是每次列舉區間，進行統計。
• 而這就是莫隊的基本思路
• 但不過莫隊的列舉是進行優化的，可以優化到\(O(N\sqrt{N})\)

基本思路

• 首先：已知\([L,R]\)的答案，那麼求\([L-1,R]\) 、\([L+1,R]\) 、\([L,R-1]\)、\([L,R+1]\)的代價為\(O(1)\)
• 如果你已知區間\([L,R]\)的答案，那麼對於區間\([l,r]\)，如果兩個區間有交集，那麼這個交集就沒有必要再去計算了，所以我們只需要移動端點即可。
• 但是代價還是\(O(N^2)\)
• 我們考慮將所有訪問的左端點進行排序
• 並按照左端點分類的，變成一塊一塊的，塊的長度為\(len\)

• 你會發現左端點在同一個塊內的詢問，經過排序後一定會在一起（很顯然啊……）
• 於是我們就想，如果對於一個塊的操作，按照右端再排一次序，
• 這樣左端點移動的次數一定不超過\(len\)，右端點移動次數總和最大是\(N\)
• 舉個例子：

• 很顯然的是，左端點的移動肯定在這個塊內，而塊的大小為\(len\)，所以每次移動的代價為\(len\)
• 並且這個塊內是按照右端點排序的。（這裡採用從大到小）
• 所以一開始右端點統計的是橙色區間
• 接下來統計藍色區間，右端點左移
• 統計黑色區間，右端點左移
• 統計紫色區間，右端點左移
• 誒你會發現在同一個塊內，右端點的移動一定是單向的！！
• 所以處理一個塊的右端點移動，最多是\(N\)次
• 並且處理下一個塊的時候，我們可以從小到大排序，這樣右端點就可以從左邊直接移到右邊
• 再下一個塊的時候從大到小，有端點就是從右到左了

時間複雜度

• 一共\(M\)次詢問，一共\(\frac{N}{len}\)個塊
• 對於每次詢問，左端點移動代價為\(len\)，所以是\(M\times len\)
• 對於一個塊，右端點移動代價為\(N\)，所以是\(\frac{N}{len}\times N\)
• \(N,M\)同級，所以總代價為$N\times len + \frac{N}{len}\times N= N(len+\frac{N}{len}) $
• 好像是個對勾函式誒！也就是基本不等式了
• \(len+\frac{N}{len} \leq 2\sqrt{\frac{N}{len}*len}\)
• 所以\(N(len+\frac{N}{len} )\leq 2N\sqrt{N}\)
• 時間複雜度為\(O(N\sqrt{N})\)

code

• 傳送門
• 處理區間不同的數字個數
• 開個桶去算就行了

#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#define MAXN 20005

struct Node {
    int l,r,num,ans;
}G[MAXN];

struct io {
    char ibuf[1 << 25] , *s;
    io() {
        fread( s = ibuf , 1 , 1 << 25 , stdin);
    }
    inline int read() {
        int u = 0, v = 1;
        while( *s < 48) v = * s++ ^ 45 ? 1 : -1;
        while(*s > 32) u = u * 10 + *s++ - 48;
        return u*v;
    }
}ip;
#define read ip.read

int cur[MAXN],book[1000005],rec[MAXN];
int N,M,size,count = 0;

inline void up(int u) {
    book[cur[u]] ++;
    if(book[cur[u]]==1) count ++;
}

inline void down(int u) {
    book[cur[u]] --;
    if(book[cur[u]]==0) count --;    
}

inline bool cmp(Node a,Node b) {
    return (a.l/size)^(b.l/size) ? a.l < b.l : ( (a.l/size)&1 ? a.r < b. r : a.r > b.r);
}

int main() {

    N = read();
    size = floor(sqrt(N));
    for(int i=1;i<=N;++i) {
        cur[i] = read();
    }
    M = read();
    std::memset(book,0,sizeof(book));
    
    for(int i=1;i<=M;++i) {
        G[i].l = read(); G[i].r = read(); G[i].num = i;
    }
    std::sort(G+1,G+M+1,cmp);

    int L = G[1].l , R = G[1].r;
    for(int i=L;i<=R;++i) up(i);
    for(int i=1;i<=M;++i) {
        rec[G[i].num] = i;
        while(R<G[i].r) up(++R);
        while(L<G[i].l) down(L++);
        while(L>G[i].l) up(--L);
        while(R>G[i].r) down(R--);
        G[i].ans = count;
    }

    for(int i=1;i<=M;++i) printf("%d\n",G[rec[i]].ans);
    return 0;
}