Submission #873200

#	Time	Username	Problem	Language	Result	Execution time	Memory
873200		vjudge1	Climbers (RMI18_climbers)	C++17	0 / 100	1088 ms	491848 KiB

climbers

// #pragma GCC target( "sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
// #pragma GCC optimize("Ofast,unroll-loops,fast-math,O3")  
#include<bits/stdc++.h>
#define f first
#define s second
#define pb push_back
#define sz(x) (int)x.size()
#define bit(a, i) ((a>>i)&1)

using namespace std;
typedef long long ll;
typedef pair<int, int> pii;

const int P = 31;
const int K = 400;
const ll inf = 1e9;
const ll INF = 1e18;
const int mod = 1e9+7;
const int maxn = 5e3 + 10;
const int dx[] = {0, 0, -1, 1};
const int dy[] = {1, -1, 0, 0};

int n;
int a[maxn];
ll d[2][maxn][maxn];

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    cin >> n;
    for(int i=1; i<=n; i++){
        cin >> a[i];
        fill(d[0][i], d[0][i]+n+1, INF);
        fill(d[1][i], d[1][i]+n+1, INF);
    }
    d[0][2][n] = d[1][1][n] = 0;
    priority_queue<pair<pair<ll, int>, pii>>q;
    q.push({{0, 0}, {2, n}});
    q.push({{0, 1}, {1, n}});
    while(sz(q)){
        int l = q.top().s.f;
        int r = q.top().s.s;
        int tp = q.top().f.s;
        ll val = -q.top().f.f;
        q.pop();
        if(l >= r) continue;
        if(val > d[tp][l][r]) continue;
        if(tp){
            if(l&1){
                int R = r;
                if(a[r-1] > a[r]) R--;
                int mn = min(a[l+1], a[R]);
                ll sum = d[1][l][r]+mn-a[l];
                if(l<n){
                    if(a[l+1] == mn && d[1][l+1][r] > sum){
                        d[1][l+1][r] = sum;
                        q.push({{-d[1][l+1][r], 1}, {l+1, r}});
                    } 
                    if(a[R] == mn && d[0][l+1][R] > sum){
                        d[0][l+1][R] = sum;
                        q.push({{-d[0][l+1][R], 0}, {l+1, R}});
                    }
                } if(l<2) continue;
                mn = min(a[l-1], a[R]);
                sum = d[1][l][r]+mn-a[l];
                if(a[l-1] == mn && d[1][l-1][r] > sum){
                    d[1][l-1][r] = sum;
                    q.push({{-d[1][l-1][r], 1}, {l-1, r}});
                } 
                if(a[R] == mn && d[0][l][R] > sum){
                    d[0][l][R] = sum;
                    q.push({{-d[0][l][R], 0}, {l, R}});
                }
            } else{
                int R = r;
                if(a[r-1] < a[r]) R--;
                int mx = max(a[l+1], a[R]);
                ll sum = d[1][l][r]+a[l]-mx;
                if(l<n){if(a[l+1] == mx && d[1][l+1][r] > sum){
                    d[1][l+1][r] = sum;
                    q.push({{-d[1][l+1][r], 1}, {l+1, r}});
                } 
                if(a[R] == mx && d[0][l+1][R] > sum){
                    d[0][l+1][R] = sum;
                    q.push({{-d[0][l+1][R], 0}, {l+1, R}});
                }} if(l<2) continue;
                mx = max(a[l-1], a[R]);
                sum = d[1][l][r]+a[l]-mx;
                if(a[l-1] == mx && d[1][l-1][r] > sum){
                    d[1][l-1][r] = sum;
                    q.push({{-d[1][l-1][r], 1}, {l-1, r}});
                } 
                if(a[R] == mx && d[0][l][R] > sum){
                    d[0][l][R] = sum;
                    q.push({{-d[0][l][R], 0}, {l, R}});
                }
            }
        } else{
            if(r&1){
                int L = l;
                if(a[l-1]>a[l]) L--;
                int mn = min(a[r+1], a[L]);
                ll sum = d[0][l][r]+mn-a[r];
                if(r<n){
                    if(a[r+1] == mn && d[0][l][r+1] > sum){
                        d[0][l][r+1] = sum;
                        q.push({{-d[0][l][r+1], 0}, {l, r+1}});
                    }
                    if(a[L] == mn && d[1][L][r+1] > sum){
                        d[1][L][r+1] = sum;
                        q.push({{-d[1][L][r+1], 1}, {L, r+1}});
                    }
                } if(r<2) continue;
                mn = min(a[r-1], a[L]);
                sum = d[0][l][r]+mn-a[r];
                if(a[r-1] == mn && d[0][l][r-1] > sum){
                    d[0][l][r-1] = sum;
                    q.push({{-d[0][l][r-1], 0}, {l, r-1}});
                }
                if(a[L] == mn && d[1][L][r] > sum){
                    d[1][L][r] = sum;
                    q.push({{-d[1][L][r], 1}, {L, r}});
                }
            } else{
                int L = l;
                if(a[l-1]<a[l]) L--;
                int mx = max(a[r+1], a[L]);
                ll sum = d[0][l][r]+a[r]-mx;
                if(r<n){
                    if(a[r+1] == mx && d[0][l][r+1] > sum){
                        d[0][l][r+1] = sum;
                        q.push({{-d[0][l][r+1], 0}, {l, r+1}});
                    }
                    if(a[L] == mx && d[1][L][r+1] > sum){
                        d[1][L][r+1] = sum;
                        q.push({{-d[1][L][r+1], 1}, {L, r+1}});
                    }
                } if(r<2) continue;
                mx = max(a[r-1], a[L]);
                sum = d[0][l][r]+a[r]-mx;
                if(a[r-1] == mx && d[0][l][r-1] > sum){
                    d[0][l][r-1] = sum;
                    q.push({{-d[0][l][r-1], 0}, {l, r-1}});
                }
                if(a[L] == mx && d[1][L][r] > sum){
                    d[1][L][r] = sum;
                    q.push({{-d[1][L][r], 1}, {L, r}});
                }
            }
        }
    }
    ll ans = INF;
    for(int i=1; i<=n; i++){   
        ans = min(ans, d[0][i][i]);
        ans = min(ans, d[1][i][i]);
    } if(ans == INF) cout << "NO\n";
    else cout << ans;
}   

• Subtask 1: 0 / 25
• Subtask 2: 0 / 25
• Subtask 3: 0 / 50