[题解]CF1407D Discrete Centrifugal Jumps

思路

注意到第二个条件和第三个条件本质相似，可以用相同的维护方式处理，因此这个只讨论第二个条件的维护方式。

定义 $dp_i$ 表示走到 $i$ 的最少步数。第一个条件的转移显然为 $dp_i \leftarrow dp_{i - 1}$。

对于第二个条件，$i$ 能向 $j$ 转移，当且仅当 $h_{i + 1 \sim j - 1}$ 都比 $h_i,h_j$ 高。不妨将 $i,j$ 的限制分开，对于 $j$ 而言，一个合法的 $i$ 必须满足 $\max_{p = i + 1}^{j - 1}\{h_p\} < h_j$。不难发现合法的 $i$ 一定是对于 $j$ 的一个后缀，可以二分 + ST 表 $\Theta(\log n)$ 求出这个后缀。

对于 $i$ 同样得满足这个条件，用一个 set 维护所有可能合法的位置。每一次插入一个 $j$，需要将所有 $\geq h_j$ 的位置全部删掉，因为对于 $j + 1$ 合法的 $i$ 必须满足 $h_i < h_j$。

现在问题变成查询一个后缀中在 set 中的元素的 $dp$ 值的 $\min$。可以在线段树上维护，将所有不在 set 中的位置赋为 inf 即可。因为每一个元素都只会进出 set 一次，时间复杂度 $\Theta(n \log n)$。

Code

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

using namespace std;

typedef pair<int,int> pii;
const int N = 3e5 + 10,M = 24;
const int inf = 1e9 + 10;
int n;
int arr[N],dp[N];
set<pii> st1,st2;

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{
    #define pot(x) (1 << x)

    int lg[N],dp1[N][M],dp2[N][M];

    inline void build(){
        for (re int i = 2;i <= n;i++) lg[i] = lg[i >> 1] + 1;
        for (re int i = 1;i <= n;i++) dp1[i][0] = dp2[i][0] = arr[i];
        for (re int j = 1;j <= lg[n];j++){
            for (re int i = 1;i + pot(j) - 1 <= n;i++){
                dp1[i][j] = min(dp1[i][j - 1],dp1[i + pot(j - 1)][j - 1]);
                dp2[i][j] = max(dp2[i][j - 1],dp2[i + pot(j - 1)][j - 1]);
            }
        }
    }

    inline int querymin(int l,int r){
        int x = lg[r - l + 1];
        return min(dp1[l][x],dp1[r - pot(x) + 1][x]);
    }

    inline int querymax(int l,int r){
        int x = lg[r - l + 1];
        return max(dp2[l][x],dp2[r - pot(x) + 1][x]);
    }

    #undef pot
}st;

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

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

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

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

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

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

    #undef ls
    #undef rs
}T1,T2;

inline void upd(pii x){
    while (!st1.empty() && (*st1.rbegin()).fst >= x.fst){
        T1.modify(1,(*st1.rbegin()).snd,inf);
        st1.erase(prev(st1.end()));
    }
    while (!st2.empty() && (*st2.begin()).fst <= x.fst){
        T2.modify(1,(*st2.begin()).snd,inf);
        st2.erase(st2.begin());
    }
    st1.insert(x); st2.insert(x);
    T1.modify(1,x.snd,dp[x.snd]); T2.modify(1,x.snd,dp[x.snd]);
}

int main(){
    n = read();
    for (re int i = 1;i <= n;i++) arr[i] = read();
    st.build();
    T1.build(1,1,n); T2.build(1,1,n);
    upd({arr[1],1});
    for (re int i = 2;i <= n;i++){
        dp[i] = dp[i - 1] + 1;
        int l = 1,r = i - 1;
        while (l < r){
            int mid = l + r >> 1;
            if (st.querymin(mid,i - 1) > arr[i]) r = mid;
            else l = mid + 1;
        }
        if (st.querymin(l,i - 1) > arr[i]) chmin(dp[i],T1.query(1,max(1,l - 1),i - 1) + 1);
        l = 1,r = i - 1;
        while (l < r){
            int mid = l + r >> 1;
            if (st.querymax(mid,i - 1) < arr[i]) r = mid;
            else l = mid + 1;
        }
        if (st.querymax(l,i - 1) < arr[i]) chmin(dp[i],T2.query(1,max(1,l - 1),i - 1) + 1);
        upd({arr[i],i});
    }
    printf("%d",dp[n]);
    return 0;
}