分块 不同数

注意：就算冲突了也要修改我们的num，因为这个调了一下午Σ( ° △ °|||)︴

哈希链表会好一点，因为我们要的是连续的指针，就不用映射map了。（TAT）

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
#define ID bl[i]
#define REP(i, s, n) for(int i = s; i <= n; i ++)
#define RAP(i, n, s) for(int i = n; i >= s; i --)
using namespace std;
const int maxn = 100000 + 10;
const int maxb = 317 + 10;
int n, Q, w[maxb][maxb], bl[maxn], pre[maxn], suf[maxn], A[maxn], SIZE, st[maxn], en[maxn], cnt[156779][maxb];
bool num[156779];
int map[maxn], ms = 0;
const int hash_max = 156779;
const int hash_check = 78389;
const int hash_delta = 78389;
const int hash_find = 3901;
struct HASH{
    int hash[hash_max];
    bool vis[hash_max];
    int hash_sortn(int v){
        v %= hash_max;
        if(v < 0) v += hash_max;
        return v;
    }
    int hash_checkn(int v){
        if(v & 1) { v = v % hash_check; if(v < 0) v += hash_check; }
        else { v = v % hash_check; if(v < 0) v += hash_check; v += hash_delta; }
        return v;
    }
    int hash_findn(int v){
        v = (v * hash_find) % hash_max;
        if(v < 0) v += hash_max;
        return v;
    }
    int find_insert(int v){
        int ids = hash_sortn(v);
        if(!vis[ids]){
            hash[ids] = v;
            vis[ids] = true;
            return map[++ ms] = ids;
        }
        else if(v == hash[ids]) return ids;
        int id = hash_checkn(v);
        if(!vis[id]){
            hash[id] = v;
            vis[id] = true;
            return map[++ ms] = id;
        }
        for(int i = id; ; i += hash_findn(i) + ids * i){
            i %= hash_max;
            if(i < 0) i += hash_max;
            if(!vis[i]){
                hash[i] = v;
                vis[i] = true;
                //map[++ ms] = i;
                //return ms;
                return map[++ ms] = i;
            }
            else if(v == hash[i]) return i;
        }
    }
}hashtable;
void read(int &x){
    x = 0; int sig = 1; char ch = getchar();
    while(!isdigit(ch)) { if(ch == '-') sig = -1; ch = getchar(); }
    while(isdigit(ch)) x = 10 * x + ch - '0', ch = getchar();
    x *= sig; return ;
}
void init(){
    read(n); read(Q); SIZE = (int)sqrt(n);
    bl[0] = bl[n + 1] = n + 1;
    REP(i, 1, n){
        read(A[i]);
        A[i] = hashtable.find_insert(A[i]);
        ID = (i - 1) / SIZE + 1;
        if(!st[ID]) st[ID] = i;
        en[ID] = i;
    }
    REP(i, 1, bl[n]){
        int ans = 0; memset(num, false, sizeof(num));
        REP(j, st[i], n){
            if(!num[A[j]]) ans ++;
            num[A[j]] = true; 
            w[i][bl[j]] = max(w[i][bl[j]], ans);
        }
    }
    REP(i, 1, bl[n]){
        REP(j, 1, ms) cnt[map[j]][i] = cnt[map[j]][i - 1]; 
        REP(j, st[i], en[i]) cnt[A[j]][i] ++;
    }
    return ;
}
void work(){
    int L, R;
    while(Q --){
        read(L); read(R); int ret = 0;
        if(bl[R] - 1 < bl[L] + 1){
            memset(num, false, sizeof(num));
            REP(i, L, R){ 
                if(!num[A[i]]) ret ++;
                num[A[i]] = true;
            }
        }
        else{
            memset(num, false, sizeof(num));
            ret = w[bl[L] + 1][bl[R] - 1];
            REP(i, L, en[bl[L]]){
                if(!num[A[i]] && cnt[A[i]][bl[R] - 1] == cnt[A[i]][bl[L]]) ret ++;
                num[A[i]] = true;
            }
            REP(i, st[bl[R]], R){
                if(!num[A[i]] && cnt[A[i]][bl[R] - 1] == cnt[A[i]][bl[L]]) ret ++;
                num[A[i]] = true;
            }
        }
        printf("%d
", ret);
    }
    return ;
}
void print(){
    
    return ;
}
int main(){
    init();
    work();
    print();
    return 0;
}

WZJ的哈希链表，快了300ms：

#include<cctype>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cstring>
using namespace std; 
inline void read(int& x)
{
    char ch=getchar();x=0;
    while(!isdigit(ch)) ch=getchar();
    while(isdigit(ch)) x=x*10+ch-'0',ch=getchar();
}
const int maxn=100010;
const int HASHSIZE=87153;
int head[HASHSIZE],next[maxn],v[maxn],tot;
int find(int val)
{
    int k=val%HASHSIZE;
    for(int x=head[k];x;x=next[x])
        if(v[x]==val) return x;
    v[++tot]=val;
    next[tot]=head[k];
    return head[k]=tot;
}
int n,m,SIZE,c[maxn],bl[maxn],st[maxn],en[maxn],cnt[10000][350],num[maxn],ans[350][350];
int main()
{
    read(n),read(m); SIZE=(int)sqrt(n);
    for(int i=1;i<=n;i++)
    {
        read(c[i]);
        c[i]=find(c[i]);
        bl[i]=(i-1)/SIZE+1;
        if(!st[bl[i]]) st[bl[i]]=i;
        en[bl[i]]=i;
    }
    for(int i=1;i<=bl[n];i++)
    {
       int tmp=0;
       for(int j=st[i];j<=n;j++)
       {
           if(++num[c[j]]==1) tmp++;
           ans[i][bl[j]]=max(ans[i][bl[j]],tmp);
       }
       memset(num,0,sizeof(num));
    }
    for(int i=1;i<=bl[n];i++)
    {
       for(int j=1;j<=tot;j++) cnt[j][i]=cnt[j][i-1];
       for(int j=st[i];j<=en[i];j++) cnt[c[j]][i]++;
    }
    int l,r,ret;
    while(m--)
    {
        read(l),read(r); ret=0;
        if(bl[l]+1>=bl[r])
        {
            for(int i=l;i<=r;i++) if(++num[c[i]]==1) ret++;
            for(int i=l;i<=r;i++) num[c[i]]=0;
            printf("%d
",ret);
        }
        else
        {
            ret=ans[bl[l]+1][bl[r]-1];
            for(int i=l;i<=en[bl[l]];i++)
            {
                if(!num[c[i]]&&cnt[c[i]][bl[r]-1]==cnt[c[i]][bl[l]]) ret++;
                num[c[i]]++;
            }
            for(int i=st[bl[r]];i<=r;i++)
            {
                if(!num[c[i]]&&cnt[c[i]][bl[r]-1]==cnt[c[i]][bl[l]]) ret++;
                num[c[i]]++;
            }
            for(int i=l;i<=en[bl[l]];i++) num[c[i]]=0;
            for(int i=st[bl[r]];i<=r;i++) num[c[i]]=0;
            printf("%d
",ret); 
        }
    }
    return 0;
}