結果

問題 No.3300 Frog Game
ユーザー ZOI-dayo
提出日時 2025-10-05 16:21:43
言語 C++23
(gcc 13.3.0 + boost 1.87.0)
結果
WA  
実行時間 -
コード長 7,202 bytes
コンパイル時間 3,155 ms
コンパイル使用メモリ 296,896 KB
実行使用メモリ 7,720 KB
最終ジャッジ日時 2025-10-05 16:22:05
合計ジャッジ時間 4,248 ms
ジャッジサーバーID
（参考情報） 		judge3 / judge5
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
other AC * 10 WA * 25
権限があれば一括ダウンロードができます
コンパイルメッセージ
main.cpp: In function ‘int solve()’:
main.cpp:72:1: warning: no return statement in function returning non-void [-Wreturn-type]
   72 | }
      | ^
main.cpp: In function ‘int solveJ()’:
main.cpp:159:1: warning: no return statement in function returning non-void [-Wreturn-type]
  159 | }
      | ^

ソースコード

diff # 

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pll = pair<ll, ll>;
using vl = vector<ll>;
template <class T> using vec = vector<T>;
template <class T> using vv = vec<vec<T>>;
template <class T> using vvv = vv<vec<T>>;
template <class T> using minpq = priority_queue<T, vec<T>, greater<T>>;
#define rep(i, r) for(ll i = 0; i < (r); i++)
#define reps(i, l, r) for(ll i = (l); i < (r); i++)
#define rrep(i, l, r) for(ll i = (r) - 1; i >= (l); i--)
#define all(a) (a).begin(), (a).end()
#define sz(a) (ll)(a).size()
template<typename T>
bool chmax(T &a, const T& b) { return a < b ? a = b, true : false; }
template <typename T>
bool chmin(T &a, const T& b) { return a > b ? a = b, true : false; }
ll modmul(ll a, ll b, ll mod) {
	ll ret = a * b - mod * ll(1.L / mod * a * b);
	return ret + mod * (ret < 0) - mod * (ret >= mod);
}
ll modpow(ll a, ll b, ll mod) {
	ll ans = 1;
	for (; b; a = modmul(a, a, mod), b /= 2)
		if (b & 1) ans = modmul(ans, a, mod);
	return ans;
}

using ull = unsigned long long;

int solve() {
    ll n, k;
    cin >> n >> k;
    // vv<ll> dp(n, vl(3, 0));
    // dp[0][0] = 1;
    // reps(i, 1, n) {
    //     dp[i][0] = dp[i-1][0] + dp[i-1][1];
    //     dp[i][1] = dp[i-1][0];
    //     dp[i][2] = dp[i-1][1] + dp[i-1][2];
    // }
    // auto sub_solve = [&](auto&& f, ll n, ll k) -> string {
    //     // 先頭がAのとき
    //     ll a_cnt = 1LL<<(n-1);
    //     // MMAを含まないのは何通り?
    //     ll a_not_cnt = dp[n-1][0] + dp[n-1][1] + dp[n-1][2];
    //     a_cnt -= a_not_cnt;
    //     if(a_cnt >= k) return "A" + f(f, n-1, k);
    //     k -= a_cnt;

    //     // ll ma_cnt = 1LL<<(n-2);
    //     // ll ma_not_cnt = dp[n-1][0] + dp[n-1][1] + dp[n-1][2];
    //     // ma_cnt -= ma_not_cnt;
    //     // if(ma_cnt >= k) return "MA" + f(f, n-2, k);
    //     // k -= ma_cnt;
    //     // return "MM" + f(f, n-2, k)
    // };
    // cout << sub_solve(sub_solve, n, k) << endl;

    // i文字の文字列であって、
    // vvv<ll> dp(n, vv<ll>(3, vl(2, 0)));
    // dp[0][0][0] = 1;
    // reps(i, 1, n) {
    //     dp[i][0] = dp[i-1][0] + dp[i-1][1];
    //     dp[i][1] = dp[i-1][0];
    //     dp[i][2] = dp[i-1][1] + dp[i-1][2];
    // }


    // return 0;
}

int solveG() {
    ll n, a, b;
    cin >> n >> a >> b;
    n--;
    if(a > b) swap(a, b);
    // n %= (a + b)*2;
    // if()


    // auto sub_solve = [&](ll n){
    //     if((n+a-1)/a%2 == 0) return 0;
    //     else return 1;
    // };
    // ll grundy;
    // if(n < b) {
    //     grundy = sub_solve(n);
    // } else {
    //     if(sub_solve(n-b) == 1) grundy = 0;
    //     else 
    // }

    ll grundy;
    if(n < b) grundy = 1;
    else if(n < a+b) grundy = 0;
    else {
        ll m = n % (a + b);
        if(m < b - a) {
            if(n / a % 2 == 0) grundy = 1;
            else grundy = 0;
        } else if(n < b) grundy = 1;
        else grundy = 0;
    }
    cout << (grundy == 0 ? "ryota" : "sepa") << endl;
    return 0;
}

int solveH() {
    ll l;
    cin >> l;
    if(l % 2 == 0) {
        ll a = (l/2)*(l/2) + 1, b = (l/2)*(l/2) - 1;
        assert(a * a - b * b == l * l);
        cout << a << " " << b << " " << l << endl;
    } else {
        ll k = l / 2;
        ll a = 2 * k * (k+1) + 1, b = 2 * k * (k+1);
        assert(a * a == b * b + l * l);
        cout << a << " " << b << " " << l << endl;
    }
    return 0;
}

int solveI() {
    ll n;
    cin >> n;
    vec<pll> ab(n);
    rep(i, n) cin >> ab[i].first >> ab[i].second;
    vv<ll> dp(n, vl(n+1, -1));
    dp[n-1][1] = ab[n-1].second;
    rrep(i, 0, n-1) {
        auto [a, b] = ab[i];
        reps(j, 1, n+1) {
            if(dp[i+1][j] >= 0)
                chmax(dp[i][j], dp[i+1][j] + a * j);
            if(dp[i+1][j-1] >= 0)
                chmax(dp[i][j], dp[i+1][j-1] + b);
        }
    }
    ll ans = 0;
    rep(j, n+1) chmax(ans, dp[0][j]);
    // rep(i, n) {
    //     rep(j, n+1) {
    //         cerr << dp[i][j] << " ";
    //     }
    //     cerr << endl;
    // }
    cout << ans << endl;
    return 0;
}

int solveJ() {
    ll n, k, d;
    cin >> n >> k >> d;
    // setを3つに分ける、mid, left, right
    // leftとrightのサイズが大きく異なる場合、midをずらすかどうかを考える
}

#line 2 "segmenttree/merge_sort_tree.hpp"
#include <algorithm>
#include <vector>

// CUT begin
// Count elements in $[A_\mathrm{begin}, ..., A_{\mathrm{end}-1}]$ which satisfy $A_i < \mathrm{query}$
// Complexity: $O(N \log N)$ for initialization, $O(\log^2 N)$ for each query
// Verified: https://codeforces.com/contest/1288/submission/68865506
template <typename T> struct merge_sort_tree {
    int N;
    std::vector<std::vector<T>> x;
    merge_sort_tree() = default;
    merge_sort_tree(const std::vector<T> &vec) : N(vec.size()) {
        x.resize(N * 2);
        for (int i = 0; i < N; i++) x[N + i] = {vec[i]};
        for (int i = N - 1; i; i--) {
            std::merge(x[i * 2].begin(), x[i * 2].end(), x[i * 2 + 1].begin(), x[i * 2 + 1].end(),
                       std::back_inserter(x[i]));
        }
    }
    int cntLess(int l, int r, T query) const {
        l += N, r += N;
        int ret = 0;
        while (l < r) {
            if (l & 1)
                ret += std::lower_bound(x[l].begin(), x[l].end(), query) - x[l].begin(), l++;
            if (r & 1)
                r--, ret += std::lower_bound(x[r].begin(), x[r].end(), query) - x[r].begin();
            l >>= 1, r >>= 1;
        }
        return ret;
    }
    int cntLesseq(int l, int r, T query) const {
        l += N, r += N;
        int ret = 0;
        while (l < r) {
            if (l & 1)
                ret += std::upper_bound(x[l].begin(), x[l].end(), query) - x[l].begin(), l++;
            if (r & 1)
                r--, ret += std::upper_bound(x[r].begin(), x[r].end(), query) - x[r].begin();
            l >>= 1, r >>= 1;
        }
        return ret;
    }
    int cntMore(int begin, int end, T query) const {
        int tot = std::max(0, std::min(end, N) - std::max(begin, 0));
        return tot - cntLesseq(begin, end, query);
    }
    int cntMoreeq(int begin, int end, T query) const {
        int tot = std::max(0, std::min(end, N) - std::max(begin, 0));
        return tot - cntLess(begin, end, query);
    }

    template <class OStream> friend OStream &operator<<(OStream &os, const merge_sort_tree &clt) {
        os << '[';
        for (int i = 0; i < clt.N; i++) os << clt.x[clt.N + i][0] << ',';
        return os << ']';
    }
};

int solveL() {
    ll n, q;
    cin >> n >> q;
    vl a(n);
    rep(i, n) cin >> a[i];
    minpq<pll> que;
    vec<ll> acc(n, -1);
    rrep(i, 0, n) {
        while(!que.empty()) {
            auto [val, idx] = que.top();
            if(val < a[i]) {
                acc[idx] = i;
                que.pop();
            } else break;
        }
        que.emplace(a[i], i);
    }
    merge_sort_tree<ll> t(acc);
    rep(Q, q) {
        ll l, r;
        cin >> l >> r;
        l--;
        cout << t.cntMoreeq(l, r, l) << endl;
    }
    return 0;
}

int main() {
	ll T = 1;
	cout << fixed << setprecision(16);
	// cin >> T;
	while (T--) solveG();
}
0