问题描述

在蓝桥王国的边疆有 𝑁​ 座高塔，每座高塔上均有一个士兵，他们被称之为皇家守卫。

每座高塔均有一个高度，第 𝑖i 座高塔的高度为 ℎ𝑖​。对于第 𝑖 座塔，若其右边存在某座塔 𝑗，满足：max⁡(ℎ𝑖,ℎ𝑖+1,ℎ𝑖+2,⋯,ℎ𝑗−1) < ℎ𝑗 则称第 𝑗 座塔为第 𝑖 座塔 "暸望塔"。

现在王国传来 𝑄 个任务，每个任务会给定两个编号 𝑥,𝑦，需要你求解第 𝑥 座高塔和 第 𝑦 座高塔的公共 "暸望塔" 数量。

𝑥,𝑦 的公共 "暸望塔" 定义为两者同时拥有的 "暸望塔"。

输入格式

第一行输入两个整数 𝑁,𝑄(1 ≤ 𝑁,𝑄 ≤ 10^5) 表示高塔个数和任务数。

第二行输入 𝑁 个整数 ℎ1,ℎ2,ℎ3,⋯,ℎ𝑛(1 ≤ ℎ𝑖 ≤ 10^9) 表示高塔的高度。

接下来 𝑄 行，每行输入两个整数 𝑥,𝑦(1 ≤ 𝑥 ≤ 𝑦 ≤ 𝑁) 表示一次任务询问。

输出格式

输出 𝑄 行，每行一个整数表示答案

输入样例

5 3
1 3 4 5 7
1 3
2 4
3 5

输出样例

2
1
0

说明

对于第一个询问，第 1 座高塔和第 3 座高塔的公共暸望塔有 4,5 号塔。

解题思路

对于瞭望塔的定义，符合单调栈求解模板，即对于第i个塔，求其右边第一个比它高的塔，使用单调递减栈从后向前遍历，配合使用after数组记录栈内元素个数，即可得到瞭望塔个数。

这题的输入输出样例非常具有迷惑性，我们需要自行模拟两个瞭望塔各自高度不同的情况，A到B高度如样例一样单调递增的情况下，其公共瞭望塔的个数是B瞭望塔的个数；但若A比B高，或者A和B之间有更高的塔，则需要分类讨论。

最终的结论是，A和B的公共瞭望塔数量，是A到B之间最高塔的瞭望塔个数。

那么这题就转化成了，多次访问任意区间最大值的问题；这里要注意，为了配合after数组的使用，线段树中应当存放的是区间最大值的下标，而非模板的区间最大值。

import java.util.*;
public class Main {
	
	static int n;
	static int[] a, after, tree;
	static LinkedList stack;
	
	static int ls(int p) { return p << 1; }
	static int rs(int p) { return p << 1 | 1; }
	
	static void push_up(int p) {
		if (a[tree[ls(p)]] > a[tree[rs(p)]]) {
			tree[p] = tree[ls(p)];
		} else {
			tree[p] = tree[rs(p)];
		}
	}
	
	static void build(int p, int pl, int pr) {
		if (pl == pr) {
			tree[p] = pl;
			return;
		}
		int mid = (pl + pr) / 2;
		build(ls(p), pl, mid);
		build(rs(p), mid + 1, pr);
		push_up(p);
	}
	
	static int query(int p, int pl, int pr, int l, int r) {
		if (l <= pl && pr <= r) {
			return tree[p];
		}
		int res = 0;
		int mid = (pl + pr) / 2;
		if (l <= mid) {
			int index = query(ls(p), pl, mid, l, r);
			res = a[res] > a[index] ? res : index;
		}
		if (mid < r) {
			int index = query(rs(p), mid + 1, pr, l, r);
			res = a[res] > a[index] ? res : index;
		}
		return res;
	}
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		int T = sc.nextInt();
		a = new int[n + 1];
		for (int i = 1; i <= n; i++) {
			a[i] = sc.nextInt();
		}
		after = new int[n + 1];
		stack = new LinkedList<>();
		for (int i = n; i > 0; i--) {
			while (!stack.isEmpty() && a[i] >= stack.peekLast()) {
				stack.pollLast();
			}
			after[i] = stack.size();
			stack.addLast(a[i]);
		}
		tree = new int[n << 2];
		build(1, 1, n);
		while (T-- > 0) {
			System.out.println(after[query(1, 1, n, sc.nextInt(), sc.nextInt())]);
		}
	}
}