結果

問題 No.2137 Stairs of Permutation
ユーザー kaichou243kaichou243
提出日時 2022-10-22 02:13:01
言語 C++17
(gcc 12.3.0 + boost 1.83.0)
結果
MLE  
実行時間 -
コード長 7,729 bytes
コンパイル時間 3,172 ms
コンパイル使用メモリ 299,888 KB
実行使用メモリ 628,224 KB
最終ジャッジ日時 2024-07-01 09:34:05
合計ジャッジ時間 14,744 ms
ジャッジサーバーID
（参考情報） 		judge1 / judge5
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
6,812 KB
testcase_01 AC 2 ms
6,944 KB
testcase_02 AC 163 ms
106,444 KB
testcase_03 AC 683 ms
441,316 KB
testcase_04 AC 566 ms
365,952 KB
testcase_05 AC 435 ms
281,828 KB
testcase_06 MLE -
testcase_07 MLE -
testcase_08 AC 105 ms
68,680 KB
testcase_09 AC 51 ms
32,772 KB
testcase_10 AC 141 ms
91,552 KB
testcase_11 MLE -
testcase_12 AC 328 ms
212,408 KB
testcase_13 AC 463 ms
300,844 KB
testcase_14 AC 683 ms
446,092 KB
testcase_15 MLE -
testcase_16 AC 316 ms
204,168 KB
testcase_17 AC 278 ms
179,704 KB
testcase_18 AC 429 ms
277,504 KB
testcase_19 AC 360 ms
229,936 KB
testcase_20 AC 234 ms
152,180 KB
testcase_21 MLE -
testcase_22 AC 2 ms
6,940 KB
testcase_23 MLE -
testcase_24 AC 2 ms
6,944 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include<bits/stdc++.h>
#include <immintrin.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#define FOR(i,n) for(int i = 0; i < (n); i++)
#define sz(c) ((int)(c).size())
#define ten(x) ((int)1e##x)
#define all(v) (v).begin(), (v).end()
using namespace std;
using ll=long long;
using P = pair<ll,ll>;
const long double PI=acos(-1);
const ll INF=1e18;
const int inf=1e9;
struct Edge {
    ll to;
    ll cost;
};
using Graph=vector<vector<Edge>>;
template <typename T>
bool chmax(T &a,const T& b){
  if (a<b){
    a=b;
    return true;
  }
  return false;
}
template <typename T>
bool chmin(T &a,const T& b){
  if (a>b){
    a=b;
    return true;
  }
  return false;
}
template<int MOD> struct Fp{
  ll val;
  constexpr Fp(long long v = 0) noexcept : val(v % MOD) {
    if (val < 0) val += MOD;
  }
  static constexpr int getmod() { return MOD; }
  constexpr Fp operator - () const noexcept {
    return val ? MOD - val : 0;
  }
  constexpr Fp operator + (const Fp& r) const noexcept { return Fp(*this) += r; }
  constexpr Fp operator - (const Fp& r) const noexcept { return Fp(*this) -= r; }
  constexpr Fp operator * (const Fp& r) const noexcept { return Fp(*this) *= r; }
  constexpr Fp operator / (const Fp& r) const noexcept { return Fp(*this) /= r; }
  constexpr Fp& operator += (const Fp& r) noexcept {
    val += r.val;
    if (val >= MOD) val -= MOD;
    return *this;
  }
  constexpr Fp& operator -= (const Fp& r) noexcept {
    val -= r.val;
    if (val < 0) val += MOD;
    return *this;
  }
  constexpr Fp& operator *= (const Fp& r) noexcept {
    val = val * r.val % MOD;
    return *this;
  }
  constexpr Fp& operator /= (const Fp& r) noexcept {
    ll a = r.val, b = MOD, u = 1, v = 0;
    while (b) {
      ll t = a / b;
      a -= t * b, swap(a, b);
      u -= t * v, swap(u, v);
    }
    val = val * u % MOD;
    if (val < 0) val += MOD;
    return *this;
  }
  constexpr bool operator == (const Fp& r) const noexcept {
    return this->val == r.val;
  }
  constexpr bool operator != (const Fp& r) const noexcept {
    return this->val != r.val;
  }
  constexpr bool operator < (const Fp& r) const noexcept {
    return this->val < r.val;
  }
  friend constexpr istream& operator >> (istream& is, Fp<MOD>& x) noexcept {
    is >> x.val;
    x.val %= MOD;
    if (x.val < 0) x.val += MOD;
    return is;
  }
  friend constexpr ostream& operator << (ostream& os, const Fp<MOD>& x) noexcept {
    return os << x.val;
  }
  friend constexpr Fp<MOD> modpow(const Fp<MOD>& a, long long n) noexcept {
    Fp<MOD> res=1,r=a;
    while(n){
      if(n&1) res*=r;
      r*=r;
      n>>=1;
    }
    return res;
  }
  friend constexpr Fp<MOD> modinv(const Fp<MOD>& r) noexcept {
        long long a = r.val, b = MOD, u = 1, v = 0;
        while (b) {
            long long t = a / b;
            a -= t * b, swap(a, b);
            u -= t * v, swap(u, v);
        }
        return Fp<MOD>(u);
  }
  ll get(){
      return val;
  }
  explicit operator bool()const{
		return val;
  }
};
template< uint32_t mod, bool fast = false >
struct MontgomeryModInt {
  using mint = MontgomeryModInt;
  using i32 = int32_t;
  using i64 = int64_t;
  using u32 = uint32_t;
  using u64 = uint64_t;
 
  static constexpr u32 get_r() {
    u32 ret = mod;
    for(i32 i = 0; i < 4; i++) ret *= 2 - mod * ret;
    return ret;
  }
 
  static constexpr u32 r = get_r();
  static constexpr u32 n2 = -u64(mod) % mod;
 
  static_assert(r * mod == 1, "invalid, r * mod != 1");
  static_assert(mod < (1 << 30), "invalid, mod >= 2 ^ 30");
  static_assert((mod & 1) == 1, "invalid, mod % 2 == 0");
 
  u32 a;
 
  MontgomeryModInt() : a{} {}
 
  MontgomeryModInt(const i64 &x)
      : a(reduce(u64(fast ? x : (x % mod + mod)) * n2)) {}
 
  static constexpr u32 reduce(const u64 &b) {
    return u32(b >> 32) + mod - u32((u64(u32(b) * r) * mod) >> 32);
  }
 
  constexpr mint& operator+=(const mint &p) {
    if(i32(a += p.a - 2 * mod) < 0) a += 2 * mod;
    return *this;
  }
 
  constexpr mint& operator-=(const mint &p) {
    if(i32(a -= p.a) < 0) a += 2 * mod;
    return *this;
  }
 
  constexpr mint& operator*=(const mint &p) {
    a = reduce(u64(a) * p.a);
    return *this;
  }
 
  constexpr mint& operator/=(const mint &p) {
    *this *= modinv(p);
    return *this;
  }
 
  constexpr mint operator-() const { return mint() - *this; }
 
  constexpr mint operator+(const mint &p) const { return mint(*this) += p; }
 
  constexpr mint operator-(const mint &p) const { return mint(*this) -= p; }
 
  constexpr mint operator*(const mint &p) const { return mint(*this) *= p; }
 
  constexpr mint operator/(const mint &p) const { return mint(*this) /= p; }
 
  constexpr bool operator==(const mint &p) const { return (a >= mod ? a - mod : a) == (p.a >= mod ? p.a - mod : p.a); }
 
  constexpr bool operator!=(const mint &p) const { return (a >= mod ? a - mod : a) != (p.a >= mod ? p.a - mod : p.a); }
 
  u32 get() const {
    u32 ret = reduce(a);
    return ret >= mod ? ret - mod : ret;
  }
 
  friend constexpr MontgomeryModInt<mod> modpow(const MontgomeryModInt<mod> &x,u64 n) noexcept {
    MontgomeryModInt<mod> ret(1), mul(x);
    while(n > 0) {
      if(n & 1) ret *= mul;
      mul *= mul;
      n >>= 1;
    }
    return ret;
  }
 
  friend constexpr MontgomeryModInt<mod> modinv(const MontgomeryModInt<mod> &r) noexcept {
        u64 a = r.get(), b = mod, u = 1, v = 0;
        while (b) {
            long long t = a / b;
            a -= t * b, swap(a, b);
            u -= t * v, swap(u, v);
        }
        return MontgomeryModInt<mod>(u);
  }
 
  friend ostream &operator<<(ostream &os, const mint &p) {
    return os << p.get();
  }
 
  friend istream &operator>>(istream &is, mint &a) {
    i64 t;
    is >> t;
    a = mint(t);
    return is;
  }
  static constexpr u32 getmod() { return mod; }
};
using mint=MontgomeryModInt<998244353>;
int main(){
    /*
        とりあえず
        c(i) := f(P)=iとなるPの個数を求めたい
        挿入dpを考える(大きい順)
        最初に挿入するときのみ1増える
        そうでないとき何も起こらない
        従って遷移が組める
        cの母関数が
        prod[k=0,n-1] (k+x)
        Taylorshiftとかを駆使してO(N log N)だが
        これは間に合わない
        なんとかしてくれ
        カエル「私がやってきた」
        ここで^3が意味を持ちそうだ
        ...2 hours later...
        ...!! なんと!!
        x^iって3階微分するとi(i-1)(i-2)x^i-3だそう
        i^3-3i^2+2iだわさ
        2階微分が
        i^2-i
        1階微分は言うまでもないだろう
        え
        これ解けたくね
        1代入すれば総和がもとまるので
        f(x)=prod[k=0,n-1] (k+x)として
        f'''(1)+3f''(1)+f'(1)を求めれば良い
        実際に微分してやってやる
        f'(1)=sum[i] n!/i
        f''(1)=わからないw
        f'''(1)=わからないw
        (ふざけてるのか？)
        考えるます
        f''(1)=2*sum[i,j] n!/ij
        f'''(1)=6*sum[i,j,k] n!/ijk
        だな
        微分公式ありがたや
        これはO(N+log(mod))でもとまるわね
    */
    int n;
    cin >> n;
    mint fac[n+1],rfac[n+1];
    fac[0]=1;
    for(int i=1;i<=n;i++) fac[i]=fac[i-1]*i;
    rfac[n]=modinv(fac[n]);
    for(int i=n-1;i>=0;i--) rfac[i]=rfac[i+1]*(i+1);
    vector<vector<mint>> dp(n+1,vector<mint>(4));
    dp[0][0]=1;
    for(int i=1;i<=n;i++){
        dp[i][0]=1;
        for(int j=1;j<4;j++){
            dp[i][j]=dp[i-1][j]+dp[i-1][j-1]*rfac[i]*fac[i-1];
        }
    }
    mint ans=fac[n]*(dp[n][1]+dp[n][2]*6+dp[n][3]*6);
    cout << ans.get() << endl;
}
0