結果

問題 No.3252 Constrained Moving
コンテスト
ユーザー tassei903
提出日時 2025-09-05 21:23:14
言語 C++23
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 25 ms / 2,000 ms
コード長 4,596 bytes
コンパイル時間 2,990 ms
コンパイル使用メモリ 279,148 KB
実行使用メモリ 7,716 KB
最終ジャッジ日時 2025-09-05 21:23:19
合計ジャッジ時間 5,231 ms
ジャッジサーバーID
（参考情報） 		judge2 / judge3
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 2
other AC * 30
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vi vector<int>
#define vl vector<ll>
#define ov4(a, b, c, d, name, ...) name
#define rep3(i, a, b, c) for(ll i = (a); i < (b); i += (c))
#define rep2(i, a, b) rep3(i, a, b, 1)
#define rep1(i, n) rep2(i, 0, n)
#define rep0(n) rep1(aaaaa, n)
#define rep(...) ov4(__VA_ARGS__, rep3, rep2, rep1, rep0)(__VA_ARGS__)
#define per(i, a, b) for(ll i = (a)-1; i >= (b); i--)
#define fore(e, v) for(auto&& e : v)
#define all(a) begin(a), end(a)
#define sz(a) (int)(size(a))
#define lb(v, x) (lower_bound(all(v), x) - begin(v))
#define eb emplace_back

template<typename T, typename S> bool chmin(T& a, const S& b) { return a > b ? a = b, 1 : 0; }
template<typename T, typename S> bool chmax(T& a, const S& b) { return a < b ? a = b, 1 : 0; }
 
const int INF = 1e9 + 100;
const ll INFL = 3e18 + 100;
 
#define i128 __int128_t
 
struct _ {
   _() { cin.tie(0)->sync_with_stdio(0), cout.tie(0); }
} __;

void debug(auto ...vs) {
    ((cerr << vs << " "), ...) << endl;
}

ll safe_div(ll a, ll b) { // floored division
		return a / b - ((a ^ b) < 0 && a % b);
}

ll safe_mod(ll a, ll b) {
    return (a % b + b) % b;
}


template<class S, S (*op)(S, S), S (*e)()> struct segtree {
   segtree(int n) : segtree(vector<S>(n, e())) {}
   segtree(const vector<S>& v) : n(sz(v)) {
      s = bit_ceil(unsigned(n));
      log = countr_zero(unsigned(s));
      d = vector<S>(2 * s, e());
      rep(i, n) d[s + i] = v[i];
      per(i, s, 1) update(i);
   }
   void set(int p, S x) {
      d[p += s] = x;
      rep(i, 1, log + 1) update(p >> i);
   }
   S prod(int l, int r) const {
      S sml = e(), smr = e();
      l += s, r += s;
      while(l < r) {
         if(l & 1) sml = op(sml, d[l++]);
         if(r & 1) smr = op(d[--r], smr);
         l >>= 1, r >>= 1;
      }
      return op(sml, smr);
   }
   S all_prod() const { return d[1]; }
   template<typename F> int max_right(int l, F f) const {
      if(l == n) return n;
      l += s;
      S sm = e();
      do {
         while(~l & 1) l >>= 1;
         if(!f(op(sm, d[l]))) {
            while(l < s) {
               l <<= 1;
               if(f(op(sm, d[l]))) sm = op(sm, d[l++]);
            }
            return l - s;
         }
         sm = op(sm, d[l++]);
      } while((l & -l) != l);
      return n;
   }
   template<typename F> int min_left(int r, F f) const {
      if(!r) return 0;
      r += s;
      S sm = e();
      do {
         r--;
         while(r > 1 and r & 1) r >>= 1;
         if(!f(op(d[r], sm))) {
            while(r < s) {
               r = (2 * r + 1);
               if(f(op(d[r], sm))) sm = op(d[r--], sm);
            }
            return r + 1 - s;
         }
         sm = op(d[r], sm);
      } while((r & -r) != r);
      return 0;
   }

   private:
   int n, s, log;
   vector<S> d;
   void update(int k) { d[k] = op(d[k * 2], d[k * 2 + 1]); }
};

constexpr int mod = 998244353;
struct mint {
   int x;
   mint(ll x_ = 0) : x(x_ % mod) {
      if(x < 0) x += mod;
   }
   mint operator-() {
      auto res = *this;
      res.x = (x ? mod - x : 0);
      return res;
   }
   mint& operator+=(mint r) {
      if((x += r.x) >= mod) x -= mod;
      return *this;
   }
   mint& operator-=(mint r) {
      if((x -= r.x) < 0) x += mod;
      return *this;
   }
   mint& operator*=(mint r) {
      x = 1LL * x * r.x % mod;
      return *this;
   }
   mint& operator/=(mint r) { return *this *= r.inv(); }
   friend mint operator+(mint a, mint b) { return a += b; }
   friend mint operator-(mint a, mint b) { return a -= b; }
   friend mint operator*(mint a, mint b) { return a *= b; }
   friend mint operator/(mint a, mint b) { return a /= b; }
   mint inv() const { return pow(mod - 2); }
   mint pow(ll b) const {
      mint a = *this, c = 1;
      while(b) {
         if(b & 1) c *= a;
         a *= a;
         b >>= 1;
      }
      return c;
   }
};
using vm = vector<mint>;

// [-1, -2, -3]
// 1 + 2 + 4

struct S{
    int a, b;
};

S op(S x, S y){
    int f = min(x.b, y.a);
    return {x.a + (y.a - f), (x.b - f) + y.b};
}

S e() {
    return {0, 0};
}

void solve() {
    int n, s, t, k;cin >> n >> s >> t >> k;
    vi a(n);
    rep(i, n)cin >> a[i];
    s--, t--;
    int x = *min_element(all(a));
    if (a[s] + a[t] <= k) {
        cout << 1 << endl;
    }
    else if (a[s] + x <= k and a[t] + x <= k) {
        cout << 2 << endl;
    }
    else {
        cout << -1 << endl;
    }
    
}


int main() {

    // int T;cin >> T;
	int T = 1;
    while(T--) {

        solve();
    }
    
}
0