題面

現在有一個序列 a1, a2, ..., an ，還有m個查詢 lj, rj (1 ≤ lj ≤ rj ≤ n) 。對於每一個查詢，請找出距離最近的兩個元素 ax 和 ay (x ≠ y) ，並且滿足以下條件：
· lj ≤ x, y ≤ rj;
· ax = ay。
兩個數字的距離是他們下標之差的絕對值 |x − y| 。

Input

單組測試資料。
第一行有兩個整數n, m (1≤n,m≤5*10^5)，表示序列的長度和查詢的次數。
第二行有n個整數a1,a2,...,an (-10^9≤ai≤10^9)。
接下來有m行，每一行給出兩個整數lj,rj (1≤lj≤rj≤n)表示一個查詢。

Output

對於每一個查詢，輸出最近的距離，如果沒有相等的元素，輸出-1。

Input示例

樣例輸入1
5 3
1 1 2 3 2
1 5
2 4
3 5

Output示例

樣例輸出1
1
-1
2

題解

離線之後，從左向右掃一遍，讓每個值儲存“當前已掃過的部分中，右邊第一個與自己相等的點到自己的距離”，然後如果當前掃到的點是詢問的右端點的話，就回答這個詢問。

 這裡面有個很巧妙的地方就是在詢問的時候按r的大小從左往右詢問，每次更新的時候更新的是和這個點最近的左邊的點。因為只有更新到第r個點時才能能查詢 l - r 的區間例如：1 2 3 4 1  只有在 r 等於 5 時才能詢問 L - 5的區間，此時更新第一個1的值為4，如果L > 1的話區間並未更新所以查詢線段樹中L- 5的最小值還是INF

然後就是這道題需要快速讀入才不會超時..........

#include <cstdio>
#include <cstring>
#include <algorithm>
#define INF 0x3f3f3f3f
#define space putchar(' ')
#define enter putchar('\n')
using namespace std;
typedef long long ll;
template <class T>
bool read(T &x){
    char c;
    bool op = 0;
    while(c = getchar(), c < '0' || c > '9')
        if(c == '-') op = 1;
        else if(c == EOF) return 0;
    x = c - '0';
    while(c = getchar(), c >= '0' && c <= '9')
        x = x * 10 + c - '0';
    if(op) x = -x;
    return 1;
}
template <class T>
void write(T x){
    if(x < 0) putchar('-'), x = -x;
    if(x >= 10) write(x / 10);
    putchar('0' + x % 10);
}

const int N = 500005;
int n, m, q, a[N], s[N], last[N], left[N], data[4*N], ans[N];
struct Query {
    int id, l, r;
    bool operator < (const Query &b) const{
        return r < b.r;
    }
} Q[N];

void build(int k, int l, int r){
    if(l == r) return (void)(data[k] = INF);
    int mid = (l + r) >> 1;
    build(k << 1, l, mid);
    build(k << 1 | 1, mid + 1, r);
    data[k] = INF;
}

void change(int k, int l, int r, int p, int x){
    if(l == r) return (void)(data[k] = x);
    int mid = (l + r) >> 1;
    if(p <= mid) change(k << 1, l, mid, p, x);
    else change(k << 1 | 1, mid + 1, r, p, x);
    data[k] = min(data[k << 1], data[k << 1 | 1]);
}

int query(int k, int l, int r, int ql, int qr){
    if(ql <= l && qr >= r) return data[k];
    int mid = (l + r) >> 1, ret = INF;
    if(ql <= mid) ret = min(ret, query(k << 1, l, mid, ql, qr));
    if(qr > mid) ret = min(ret, query(k << 1 | 1, mid + 1, r, ql, qr));
    return ret;
}

int main(){

    read(n), read(q);
    for(int i = 1; i <= n; i++)
        read(a[i]), s[i] = a[i];
    sort(s + 1, s + n + 1);
    int m = unique(s + 1, s + n + 1) - s - 1;
    
    for(int i = 1; i <= n; i++){
        a[i] = lower_bound(s + 1, s + m + 1, a[i]) - s;
        left[i] = last[a[i]];
        last[a[i]] = i;
    }

    build(1, 1, n);
    
    for(int i = 1; i <= q; i++)
        Q[i].id = i, read(Q[i].l), read(Q[i].r);
    sort(Q + 1, Q + q + 1);

    for(int i = 1, j = 1; i <= n && j <= q; i++){
    
        if(left[i]) change(1, 1, n, left[i], i - left[i]);
    
        while(j <= q && i == Q[j].r){
    
            ans[Q[j].id] = query(1, 1, n, Q[j].l, Q[j].r);
            j++;
        }
    }
    for(int i = 1; i <= q; i++)
        write(ans[i] < INF ? ans[i] : -1), enter;
    return 0;
}