Flying Squirrel【RMQ+思维】【2018 ICPC Asia Nakhon Pathom Regional Contest.A题】

题记——线段树会T…… 在VJ上返回的是MLE，在GYM上返回的则是TLE。

VJ链接

GYM链接

题面

---

  一开始的思维是用线段树去维护区间的最大值，但是就算用了快速读入还是T了，所以想到了存在那种查询很大的情况，这个时候就是需要离线查询的区间，类似于LCA，我使用了RMQ来做。

  对了，先讲解一下题意吧，给出数N、M，表示了有N个高度以及M次查询，接下来N个数h[i]表示了这几个高度，然后我们有这样的查询，【L，R】表示从L到R的最长路径，也许会没有一条路径，若其中一个为0，则直接输出从该点出发所能达到的最远的路径长度，我们定义能走的路径是这样的，【L，R】（假设L为高点）从L出发，我们可以跳转到他们的中间的一点X1，其中（L，X1】这段区间内的最大值得"<h[L]"，然后我们可以从L跳至X1，同理X1，我们这么跳的最远距离是多少，所要查询的就是这个。

思路：

  这道题想了挺久的，还看了别人的做法（挺不想写RMQ的一开始，所以就是要敲线段树区间最大值。真香。）。我们可以去记录深度来做这道题，一开始就是要从最高的点开始出发，如果有多个等高的最高点，我们就要从最左边的那个点出发。然后对应的，因为我们控制了左端，所以再走该点的左边区间肯定是严格小于它的，然后我们再去更新它的右边的区间，看到右边的最大值的下标，然后我们就被限制住了，该点出发向右的话，只能找区间内的最大值q，如果h[q] < h[p]，那么就是可以退出循环，直接去查询了；但是如果h[q] == h[p]，那么就有必要在他两的区间内在去跑了，跑出来的值更新p、q两点的最远到达关系。

  然后就是输出了，如果是两个点，首先判断其间的区间的高度最大值的关系还有两点的高度关系，符合条件的话直接输出深度差即可，不符合条件的话就是0了，如果只有一个点的话，就是需要用到之前存起来的最远到达的ans了。

  为什么可以这样子去输出呢？可以这样子去考虑，对于一段区间，我们知道该区间的最大值（相等向左（id小的）取）的id为p，然后就保证了从[l, p-1]这个区间一定是最大高度的大小小于h[p]的，所以左区间可以去直接搜索，对于右区间，我们做了上面的处理，保证了一定是两个最大值的中间夹了一段小的数。

  输出可以直接用深度的关系，前提是保证了他们所构成的区间的中间段，没有一个"≥"他们的高度。接下去，就是为什么深度可以用来表示，深度代表了我们访问到这个点的关系，和上一个比它高的点的和它的点的关系，在保证他们所构成区间段的因素关系的同时也就意味着保证了这两个点是有关系的，可以是对应的关系链上的，我们的深度差就能用上了（保证是这样的），也就是最大的深度减去最小的深度即可了。

---

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define efs 1e-8
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
namespace fastIO {
#define BUF_SIZE 100000
    //fread -> read
    bool IOerror = 0;
    inline char nc() {
        static char buf[BUF_SIZE], *p1 = buf + BUF_SIZE, *pend = buf + BUF_SIZE;
        if(p1 == pend) {
            p1 = buf;
            pend = buf + fread(buf, 1, BUF_SIZE, stdin);
            if(pend == p1) {
                IOerror = 1;
                return -1;
            }
        }
        return *p1++;
    }
    inline bool blank(char ch) {
        return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
    }
    inline void read(int &x) {
        char ch;
        while(blank(ch = nc()));
        if(IOerror) return;
        for(x = ch - '0'; (ch = nc()) >= '0' && ch <= '9'; x = x * 10 + ch - '0');
    }
#undef BUF_SIZE
};
using namespace fastIO;
const int maxN = 1e5 + 7;
int N, M, h[maxN], deep[maxN], ans[maxN];
struct node
{
    int h, id;
    node(int a=0, int b=0):h(a), id(b) {}
    friend bool operator < (node e1, node e2) { return e1.h == e2.h ? e1.id > e2.id : e1.h < e2.h; }
}tree[maxN<<2];
void pushup(int rt)
{
    if(tree[rsn] < tree[lsn]) tree[rt] = tree[lsn];
    else tree[rt] = tree[rsn];
}
void buildTree(int rt, int l, int r)
{
    if(l == r)
    {
        tree[rt] = node(h[l], l);
        return;
    }
    int mid = HalF;
    buildTree(Lson);
    buildTree(Rson);
    pushup(rt);
}
node query(int rt, int l, int r, int ql, int qr)
{
    if(ql <= l && qr >= r) return tree[rt];
    int mid = HalF;
    if(qr <= mid) return query(QL);
    else if(ql > mid) return query(QR);
    else return max(query(QL), query(QR));
}
int LOG[maxN], maxx[maxN][20];
int MAX(int x, int y) { return h[x] >= h[y] ? x : y; }
int Query(int l, int r)
{
    int k = LOG[r - l + 1];
    return MAX(maxx[l][k], maxx[r - (1<<k) + 1][k]);
}
int solve(int l, int r, int depth)
{
    if(l > r) return -1;
    int res = 0, p = /*query(1, 1, N, l, r).id*/ Query(l, r), q = 0, tmp = 0;
    deep[p] = depth;
    res = ans[p] = solve(l, p - 1, depth + 1) + 1;
    while(p < r)
    {
        //q  = query(1, 1, N, p + 1, r).id;
        q = Query(p + 1, r);
        if(h[p] ^ h[q]) break;
        deep[q] = depth;
        tmp = solve(p + 1, q - 1, depth + 1) + 1;
        res = max(res, tmp);
        ans[q] = tmp;
        ans[p] = max(ans[p], tmp);
        p = q;
    }
    ans[p] = max(ans[p], solve(p + 1, r, depth + 1) + 1);
    res = max(res, ans[p]);
    return res;
}
inline void init_RMQ()
{
    LOG[0] = -1;
    for(int i=1; i<=N; i++) LOG[i] = LOG[i>>1] + 1;
    for(int i=1; i<=N; i++) maxx[i][0] = i;
    for(int i=1; (1<<i) <= N; i++)
    {
        for(int j=1; j + (1<<i) - 1 <= N; j++)
        {
            maxx[j][i] = MAX(maxx[j][i-1], maxx[j + (1<<(i - 1))][i-1]);
        }
    }
}
int main()
{
    scanf("%d%d", &N, &M);
    for(int i=1; i<=N; i++) scanf("%d", &h[i]);
    //read(N);    read(M);
    //for(int i=1; i<=N; i++) read(h[i]);
    //buildTree(1, 1, N);
    init_RMQ();
    solve(1, N, 0);
    int x, y;
    while(M--)
    {
        scanf("%d%d", &x, &y);
        //read(x);    read(y);
        if(h[x] < h[y]) swap(x, y);
        if(!y) { printf("%d\n", ans[x]); continue; }
        if(h[x] <= ( x < y ? /*query(1, 1, N, x + 1, y).h*/ h[Query(x + 1, y)] : /*query(1, 1, N, y, x - 1).h )*/ h[Query(y, x - 1)])) { printf("0\n"); continue; }
        printf("%d\n", deep[y] - deep[x]);
    }
    return 0;
}