[题解]AT_abc254_g [ABC254G] Elevators

思路

假定 $y_i < w_i$。

首先有一个很显然的事实：坐电梯只往上，不往下。因为如果坐了一个电梯往下，然后换乘往上，明显不如立刻换乘然后往上。

所以问题转为求最少的换乘次数。为了代码的简洁，我们先把在同一栋楼中有交的电梯合为同一班电梯。即将 $l_1 \leq l_2 \leq r_1 \leq r_2$ 的两班电梯合并为 $[l_1,r_2]$ 的一班电梯。

考虑倍增地跳。定义 $dp_{i,j}$ 表示从第 $i$ 层出发换乘 $2^j$ 能到达的最高的楼层，转移是平凡的。

现在考虑求解 $dp_{i,0}$。对于每一班 $[l,r]$ 的电梯都可以从 $x \in [l,r]$ 到达 $y \in [l,r]$。所以对于 $\forall x \in [l,r],dp_{x,0} \leftarrow \max(dp_{x,0},r,x)$。这个操作可以上线段树解决。

对于每一次询问，需要注意的是如果能够不换乘能直接到达终点，直接输出 $w_i - y_i$，因为倍增地跳会多算出一次换乘。

代码细节较多，用 vector 离散化要注意下标问题，容易导致 UB。

Code

#include <bits/stdc++.h>
#define re register
#define fst first
#define snd second
#define chmax(a,b) (a = max(a,b))

using namespace std;

typedef pair<int,int> pii;
const int N = 8e5 + 10,M = 24,inf = 1e9 + 10;
int n,m,q,sz;
int lg[N],dp[N][M];
vector<int> pt;
vector<pii> v[N];

struct Query{
    int a,b,c,d;
}Q[N];

inline int read(){
    int r = 0,w = 1;
    char c = getchar();
    while (c < '0' || c > '9'){
        if (c == '-') w = -1;
        c = getchar();
    }
    while (c >= '0' && c <= '9'){
        r = (r << 3) + (r << 1) + (c ^ 48);
        c = getchar();
    }
    return r * w;
}

struct seg{
    #define ls(u) (u << 1)
    #define rs(u) (u << 1 | 1)

    struct node{
        int l,r;
        int Max,tag;
    }tr[N << 2];

    inline void calc(int u,int k){
        chmax(tr[u].Max,k); chmax(tr[u].tag,k);
    }

    inline void pushup(int u){
        tr[u].Max = max(tr[ls(u)].Max,tr[rs(u)].Max);
    }

    inline void pushdown(int u){
        if (tr[u].tag){
            calc(ls(u),tr[u].tag); calc(rs(u),tr[u].tag);
            tr[u].tag = 0;
        }
    }

    inline void build(int u,int l,int r){
        tr[u] = {l,r};
        if (l == r) return;
        int mid = l + r >> 1;
        build(ls(u),l,mid); build(rs(u),mid + 1,r);
    }

    inline void modify(int u,int l,int r,int k){
        if (l <= tr[u].l && tr[u].r <= r) return calc(u,k);
        pushdown(u);
        int mid = tr[u].l + tr[u].r >> 1;
        if (l <= mid) modify(ls(u),l,r,k);
        if (r > mid) modify(rs(u),l,r,k);
        pushup(u);
    }

    inline int query(int u,int x){
        if (tr[u].l == tr[u].r) return tr[u].Max;
        pushdown(u);
        int mid = tr[u].l + tr[u].r >> 1;
        if (x <= mid) return query(ls(u),x);
        else return query(rs(u),x);
    }

    #undef ls
    #undef rs
}T;

#define find(x) (lower_bound(pt.begin(),pt.end(),x) - pt.begin() + 1)

inline pii get(int x,int y){
    int l = y,r = y;
    auto it = upper_bound(v[x].begin(),v[x].end(),make_pair(y,inf));
    if (it != v[x].begin() && (*prev(it)).snd >= y){
        l = (*prev(it)).fst; r = (*prev(it)).snd;
    }
    return {l,r};
}

int main(){
    n = read(),m = read(),q = read();
    for (re int i = 1,a,b,c;i <= m;i++){
        a = read(),b = read(),c = read();
        v[a].push_back({b,c});
        pt.push_back(b); pt.push_back(c);
    }
    for (re int i = 1,a,b,c,d;i <= q;i++){
        a = read(),b = read(),c = read(),d = read();
        if (b > d){
            swap(a,c); swap(b,d);
        }
        Q[i] = {a,b,c,d};
        pt.push_back(b); pt.push_back(d);
    }
    sort(pt.begin(),pt.end());
    pt.erase(unique(pt.begin(),pt.end()),pt.end());
    const int num = pt.size();
    for (re int i = 1;i <= n;i++){
        vector<pii> tmp;
        sort(v[i].begin(),v[i].end());
        pii s = {-1,-1};
        for (pii p:v[i]){
            if (!~s.fst) s = p;
            else{
                if (s.fst <= p.fst && p.fst <= s.snd) chmax(s.snd,p.snd);
                else{
                    tmp.push_back(s);
                    s = p;
                }
            }
        }
        if (~s.fst) tmp.push_back(s);
        v[i] = tmp; sz += v[i].size();
    }
    for (re int i = 2;i <= sz;i++) lg[i] = lg[i >> 1] + 1;
    T.build(1,1,num);
    for (re int i = 1;i <= n;i++){
        for (pii p:v[i]){
            int l = find(p.fst),r = find(p.snd);
            T.modify(1,l,r,r);
        }
    }
    for (re int i = 1;i <= num;i++) dp[i][0] = max(i,T.query(1,i));
    for (re int j = 1;j <= lg[sz];j++){
        for (re int i = 1;i <= num;i++) dp[i][j] = dp[dp[i][j - 1]][j - 1];
    }
    for (re int i = 1;i <= q;i++){
        int a = Q[i].a,b = Q[i].b,c = Q[i].c,d = Q[i].d;
        int ans = d - b;
        pii s1 = get(a,b),s2 = get(c,d);
        if (a == c && s1.snd == s2.snd){
            printf("%d\n",ans); continue;
        }
        int now = find(s1.snd);
        for (re int j = lg[sz];~j;j--){
            int tmp = dp[now][j];
            if (tmp && d > pt[tmp - 1]){
                now = tmp; ans += (1 << j);
            }
        }
        if (pt[now - 1] >= s2.fst) printf("%d\n",ans + 1);
        else{
            int tmp = dp[now][0] - 1;
            if (0 <= tmp && tmp < num && d <= pt[tmp]) printf("%d\n",ans + 2);
            else puts("-1");
        }
    }
    return 0;
}