#748624 (C++17) No.1885 Flat Permutation

• 問題: No.1885 Flat Permutation
• ユーザー: MatsuTaku
• 提出日時: 2022-03-25 22:03:38
• 言語: C++17 (gcc 13.2.0 + boost 1.83.0)
• 結果: AC
• 実行時間: 5 ms / 2,000 ms
• コード長: 4,188 bytes
• コンパイル時間: 3,797 ms
• コンパイル使用メモリ: 301,800 KB
• 実行使用メモリ: 5,376 KB
• 最終ジャッジ日時: 2024-04-22 06:43:44
• 合計ジャッジ時間: 4,960 ms
• ジャッジサーバーID （参考情報）: judge2 / judge5

入力	結果	実行時間; 実行使用メモリ
testcase_00	AC	5 ms; 5,248 KB
testcase_01	AC	5 ms; 5,376 KB
testcase_02	AC	4 ms; 5,376 KB
testcase_03	AC	5 ms; 5,376 KB
testcase_04	AC	4 ms; 5,376 KB
testcase_05	AC	4 ms; 5,376 KB
testcase_06	AC	5 ms; 5,376 KB
testcase_07	AC	4 ms; 5,376 KB
testcase_08	AC	5 ms; 5,376 KB
testcase_09	AC	5 ms; 5,376 KB
testcase_10	AC	5 ms; 5,376 KB
testcase_11	AC	5 ms; 5,376 KB
testcase_12	AC	4 ms; 5,376 KB
testcase_13	AC	4 ms; 5,376 KB
testcase_14	AC	5 ms; 5,376 KB
testcase_15	AC	5 ms; 5,376 KB
testcase_16	AC	4 ms; 5,376 KB
testcase_17	AC	4 ms; 5,376 KB
testcase_18	AC	4 ms; 5,376 KB
testcase_19	AC	4 ms; 5,376 KB
testcase_20	AC	5 ms; 5,376 KB
testcase_21	AC	5 ms; 5,376 KB
testcase_22	AC	5 ms; 5,376 KB
testcase_23	AC	5 ms; 5,376 KB
testcase_24	AC	4 ms; 5,376 KB
testcase_25	AC	5 ms; 5,376 KB
testcase_26	AC	4 ms; 5,376 KB
testcase_27	AC	5 ms; 5,376 KB
testcase_28	AC	4 ms; 5,376 KB
testcase_29	AC	5 ms; 5,376 KB
testcase_30	AC	4 ms; 5,376 KB
testcase_31	AC	5 ms; 5,376 KB
testcase_32	AC	4 ms; 5,376 KB
testcase_33	AC	4 ms; 5,376 KB
testcase_34	AC	5 ms; 5,376 KB
testcase_35	AC	5 ms; 5,376 KB
testcase_36	AC	5 ms; 5,376 KB
testcase_37	AC	4 ms; 5,376 KB
testcase_38	AC	4 ms; 5,376 KB
testcase_39	AC	4 ms; 5,376 KB
testcase_40	AC	4 ms; 5,376 KB
testcase_41	AC	4 ms; 5,376 KB
testcase_42	AC	4 ms; 5,376 KB
testcase_43	AC	4 ms; 5,376 KB
testcase_44	AC	4 ms; 5,376 KB
testcase_45	AC	5 ms; 5,376 KB
testcase_46	AC	4 ms; 5,376 KB

ソースコード

#line 1 "c.cpp"
/*
  Author : MatsuTaku
  Date   : 03/25/22
*/

#include <bits/stdc++.h>
#include <x86intrin.h>
//#include <atcoder/all>
#line 3 "/mnt/c/Users/tkmma/competitive_programming/CPBF/library/include/modular.hpp"

template <long long MOD> class Modular {
private:
  long long val_;

public:
  constexpr Modular() : val_(0) {}
  constexpr Modular(long long v) : val_(v % MOD) {
    if (val_ < 0)
      val_ += MOD;
  }

  constexpr long long val() const { return val_; }
  constexpr Modular &operator+=(Modular x) {
    val_ += x.val();
    if (val_ >= MOD)
      val_ %= MOD;
    return *this;
  }
  constexpr Modular operator-() const { return {MOD - val_}; }
  constexpr Modular &operator-=(Modular x) {
    val_ -= x.val();
    if (val_ < 0)
      val_ += MOD;
    return *this;
  }
  constexpr Modular &operator*=(Modular x) {
    val_ *= x.val();
    if (val_ >= MOD)
      val_ %= MOD;
    return *this;
  }
  constexpr Modular pow(long long p) const {
    Modular t = 1;
    Modular u = *this;
    while (p) {
      if (p & 1)
        t *= u;
      u *= u;
      p >>= 1;
    }
    return t;
  }
  friend constexpr Modular pow(Modular x, long long p) { return x.pow(p); }
  constexpr Modular inv() const { return pow(MOD - 2); }
  constexpr Modular &operator/=(Modular x) { return *this *= x.inv(); }
  constexpr Modular operator+(Modular x) const { return Modular(*this) += x; }
  constexpr Modular operator-(Modular x) const { return Modular(*this) -= x; }
  constexpr Modular operator*(Modular x) const { return Modular(*this) *= x; }
  constexpr Modular operator/(Modular x) const { return Modular(*this) /= x; }
  constexpr Modular &operator++() { return *this += 1; }
  constexpr Modular operator++(int) {
    Modular c = *this;
    ++(*this);
    return c;
  }
  constexpr Modular &operator--() { return *this -= 1; }
  constexpr Modular operator--(int) {
    Modular c = *this;
    --(*this);
    return c;
  }

  constexpr bool operator==(Modular x) const { return val() == x.val(); }
  constexpr bool operator!=(Modular x) const { return val() != x.val(); }
  constexpr bool operator<(Modular x) const { return val() < x.val(); };
  constexpr bool operator<=(Modular x) const { return val() <= x.val(); };
  constexpr bool operator>(Modular x) const { return val() > x.val(); };
  constexpr bool operator>=(Modular x) const { return val() >= x.val(); };

  friend std::ostream &operator<<(std::ostream &os, const Modular &x) {
    return os << x.val();
  }
  friend std::istream &operator>>(std::istream &is, Modular &x) {
    return is >> x.val_;
  }
};

#line 10 "c.cpp"
#define _overload3(_1, _2, _3, target, ...) target
#define _REP(i, l, r) for (int i = (l), i##_less = (r); i < i##_less; i++)
#define _rep(i, n) _REP(i, 0, n)
#define rep(args...) _overload3(args, _REP, _rep)(args)
#define _RREP(i, l, r) for (int i = (r)-1, i##_least = (l); i >= i##_least; i--)
#define _rrep(i, n) _RREP(i, 0, n)
#define rrep(args...) _overload3(args, _RREP, _rrep)(args)
#define chmax(dst, x) dst = max(dst, (x))
#define chmin(dst, x) dst = min(dst, (x))
using namespace std;
using lint = long long int;
using ulint = unsigned long long int;
template <typename T> using vvec = vector<vector<T>>;
template <typename T> vvec<T> make_vvec(int n, int m, T v) {
  return vvec<T>(n, vector<T>(m, v));
}
template <typename T>
using min_queue = priority_queue<T, vector<T>, greater<T>>;

class Solver {
public:
  Solver();
  void solve();
};

using mint = Modular<998244353>;
Solver::Solver() {}

void Solver::solve() {
  int n, x, y;
  cin >> n >> x >> y;
  vector<mint> dp(2e5 + 1);
  dp[0] = 1;
  rep(i, 0, 2e5) {
    dp[i + 1] += dp[i];
    if (i + 3 <= 2e5)
      dp[i + 3] += dp[i];
  }
  if (x > y)
    swap(x, y);
  mint ans = 0;
  if (x == 1 or y == n) {
    if (x == 1 and y == n)
      ans = dp[y - x];
    else {
      ans = dp[y - x - 1];
    }
  } else {
    if (y - x == 1)
      ans = 0;
    else {
      ans = dp[y - x - 2];
    }
  }
  cout << ans << endl;
}

int main() {
  cin.tie(nullptr);
  ios::sync_with_stdio(false);
  cout << fixed << setprecision(10);
  Solver solver;
  int t = 1;
  //  cin>>t;
  while (t--) {
    solver.solve();
  }
  return 0;
}