題意

將顏色由淺到深用\(1\)到\(N\)標號（\(1\)是很淺的顏色，\(N\)是很深的顏色）。
從而她可以用一個長為\(N\)的整數陣列來描述她想要給柵欄的每一小段塗上的顏色。

初始時，所有柵欄小段均未被上色。
一筆可以給任意連續若干小段塗上同一種顏色，但只能用較深的顏色覆蓋較淺的顏色。

有\(Q\)個詢問，每次詢問區間\([l,r]\)之間的柵欄上色用的最少筆數。
\(100\%, 1≤N,Q≤2*10^5\)。

思路

先考慮如何暴力求出一個區間的答案。

對於兩個相同的顏色\(x\)，它們如何可以用一筆來塗：當它們之間的最小值大於等於\(x\)。
如果比\(x\)小，那麼塗了\(x\)後，最小值不能覆蓋在\(x\)

對於每個區間，得出了一個\(O(N)\)的演算法：
即列舉每一個數，找到上一個相同的數，判斷區間最小值（利用ST表）與它們的關係。

可以先預處理\(sum_i\)代表\(1 \sim i\)的答案。

現在對於區間\([l,r]\)，我們可以考慮答案為\(sum_r-sum_{l-1}\)。
然而，這個區間存在一些塗色筆畫是從\([1,l-1]\)中的顏色接著塗過來的，我們還要統計這些個數。
具體地，在預處理時算出當前點是從哪裡塗過來的，對於每個詢問即查詢\([l,r]\)中\(\leq l-1\)的個數。

程式碼

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

int n, q, m, tot;
int a[200001], f[200001][19], lg[200001], las[200001], pre[200001], sum[200001], root[200001];

struct SegmentTree {
    int lc, rc;
    int dat;
} tree[20000001];

int ask(int now, int l, int r, int L, int R) {
    if (L <= l && r <= R)
		return tree[now].dat;
    int mid = l + r >> 1, res = 0;
    if (L <= mid)
		res += ask(tree[now].lc, l, mid, L, R);
    if (R > mid)
		res += ask(tree[now].rc, mid + 1, r, L, R);
	return res;//woshishabi
}

int query(int l, int r) {
	if (l > r)
		return a[l];
	int x = lg[r - l + 1];
	return std::min(f[l][x], f[r - (1 << x) + 1][x]);
}

int build(int l, int r) {
    int p = ++tot;
    if (l == r)
        return p;
    int mid = l + r >> 1;
    tree[p].lc = build(l, mid);
    tree[p].rc = build(mid + 1, r);
    return p;
}

int insert(int now, int l, int r, int x) {
    int p = ++tot;
    tree[p] = tree[now];
    if (l == r) {
        tree[p].dat++;
        return p;
    }
    int mid = l + r >> 1;
    if (x <= mid)
        tree[p].lc = insert(tree[now].lc, l, mid, x);
    else
        tree[p].rc = insert(tree[now].rc, mid + 1, r, x);
    tree[p].dat = tree[tree[p].lc].dat + tree[tree[p].rc].dat;
    return p;
}

int main() {
	scanf("%d %d", &n, &q);
	lg[0] = -1;
	for (int i = 1; i <= n; i++)
		scanf("%d", &a[i]), m = std::max(m, a[i]), f[i][0] = a[i], lg[i] = lg[i >> 1] + 1, pre[i] = n + 1;
	for (int j = 1; j <= 19; j++)
		for (int i = 1; i + (1 << j) - 1 <= n; i++)
			f[i][j] = std::min(f[i][j - 1], f[i + (1 << j - 1)][j - 1]);
	int tmp = 0;
	for (int i = 1; i <= n; i++) {
		if (las[a[i]] && query(las[a[i]] + 1, i - 1) >= a[i])
			sum[i] = tmp, pre[i] = las[a[i]];
		else
			sum[i] = ++tmp;
		las[a[i]] = i;
	}
	root[0] = build(1, n);
	for (int i = 1; i <= n; i++)
		root[i] = pre[i] <= n ? insert(root[i - 1], 1, n, pre[i]) : root[i - 1];
	int l, r;
	for (int i = 1; i <= q; i++) {
		scanf("%d %d", &l, &r);
		if (l == 1) {
			printf("%d\n", sum[r]);
			continue;
		}
		printf("%d\n", sum[r] - sum[l - 1] + (ask(root[r], 1, n, 1, l - 1) - ask(root[l - 1], 1, n, 1, l - 1)));
	}
}