Problem p03989 (C++)

Buggy submission (status: Runtime Error):
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define X first
#define Y second
#define pb push_back
#define rep(X, Y) for (int(X) = 0; (X) < (Y); ++(X))
#define reps(X, S, Y) for (int(X) = S; (X) < (Y); ++(X))
#define rrep(X, Y) for (int(X) = (Y)-1; (X) >= 0; --(X))
#define rreps(X, S, Y) for (int(X) = (Y)-1; (X) >= (S); --(X))
#define repe(X, Y) for ((X) = 0; (X) < (Y); ++(X))
#define peat(X, Y) for (; (X) < (Y); ++(X))
#define all(X) (X).begin(), (X).end()
#define rall(X) (X).rbegin(), (X).rend()
#define eb emplace_back
#define UNIQUE(X) (X).erase(unique(all(X)), (X).end())
#define Endl endl

using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
template <class T> using vv = vector<vector<T>>;
template <class T> ostream &operator<<(ostream &os, const vector<T> &t) {
  os << "{";
  rep(i, t.size()) { os << t[i] << ","; }
  os << "}" << endl;
  return os;
}
template <class T, size_t n>
ostream &operator<<(ostream &os, const array<T, n> &t) {
  os << "{";
  rep(i, n) { os << t[i] << ","; }
  os << "}" << endl;
  return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &t) {
  return os << "(" << t.first << "," << t.second << ")";
}
template <class S, class T, class U>
ostream &operator<<(ostream &os, const tuple<S, T, U> &t) {
  return os << "(" << get<0>(t) << "," << get<1>(t) << "," << get<2>(t) << ")";
}
template <class S, class T, class U, class V>
ostream &operator<<(ostream &os, const tuple<S, T, U, V> &t) {
  return os << "(" << get<0>(t) << "," << get<1>(t) << "," << get<2>(t) << ","
            << get<3>(t) << ")";
}
template <class T> inline bool MX(T &l, const T &r) {
  return l < r ? l = r, 1 : 0;
}
template <class T> inline bool MN(T &l, const T &r) {
  return l > r ? l = r, 1 : 0;
}
// #undef NUIP
#ifdef NUIP
#define out(args...)                                                           \
  {                                                                            \
    vector<string> a_r_g_s = s_p_l_i_t(#args, ',');                            \
    e_r_r(a_r_g_s.begin(), args);                                              \
  }
vector<string> s_p_l_i_t(const string &s, char c) {
  vector<string> v;
  int d = 0, f = 0;
  string t;
  for (char c : s) {
    if (!d && c == ',')
      v.pb(t), t = "";
    else
      t += c;
    if (c == '\"' || c == '\'')
      f ^= 1;
    if (!f && c == '(')
      ++d;
    if (!f && c == ')')
      --d;
  }
  v.pb(t);
  return move(v);
}
void e_r_r(vector<string>::iterator it) {}
template <typename T, typename... Args>
void e_r_r(vector<string>::iterator it, T a, Args... args) {
  if (*it == " 1" || *it == "1")
    cerr << endl;
  else
    cerr << it->substr((*it)[0] == ' ', it->length()) << " = " << a << ", ";
  e_r_r(++it, args...);
}
#else
#define out
#endif
template <typename T> vector<T> table(int n, T v) { return vector<T>(n, v); }
template <class... Args> auto table(int n, Args... args) {
  auto val = table(args...);
  return vector<decltype(val)>(n, move(val));
}
const ll MOD = 924844033;

ll modpow(ll r, ll n, ll m = MOD) {
  ll re = 1, d = r % m;
  if (n < 0)
    (n %= m - 1) += m - 1;
  for (; n; n /= 2) {
    if (n & 1)
      (re *= d) %= m;
    (d *= d) %= m;
  }
  return re;
}
template <int mod = MOD> struct modInt {
  int v;
  modInt(int v = 0) : v(v) {}
  modInt operator+(const modInt &n) {
    return v + n.v < mod ? v + n.v : v + n.v - mod;
  }
  modInt operator-(const modInt &n) {
    return v - n.v < 0 ? v - n.v + mod : v - n.v;
  }
  modInt operator*(const modInt &n) { return ll(v) * n.v % mod; }
  modInt operator/(const modInt &n) {
    return ll(v) * modpow(n.v % mod, -1, mod) % mod;
  }
  modInt operator+(const ll &n) { return v + n < mod ? v + n : v + n - mod; }
  modInt operator-(const ll &n) { return v - n < 0 ? v - n + mod : v - n; }
  modInt operator*(const ll &n) { return ll(v) * (n % mod) % mod; }
  modInt operator/(const ll &n) {
    return ll(v) * modpow(n % mod, -1, mod) % mod;
  }
  modInt &operator+=(const modInt &n) {
    v += n.v;
    if (v >= mod)
      v -= mod;
    return *this;
  }
  modInt &operator-=(const modInt &n) {
    v -= n.v;
    if (v < 0)
      v += mod;
    return *this;
  }
  modInt &operator*=(const modInt &n) {
    v = ll(v) * n.v % mod;
    return *this;
  }
  modInt &operator/=(const modInt &n) {
    v = ll(v) * modpow(n.v, -1, mod) % mod;
    return *this;
  }
  modInt &operator+=(const ll &n) {
    v += n;
    if (v >= mod)
      v -= mod;
    return *this;
  }
  modInt &operator-=(const ll &n) {
    v -= n;
    if (v < 0)
      v += mod;
    return *this;
  }
  modInt &operator*=(const ll &n) {
    v = ll(v) * n % mod;
    return *this;
  }
  modInt &operator/=(const ll &n) {
    v = ll(v) * modpow(n, -1, mod) % mod;
    return *this;
  }
};
template <int mod> ostream &operator<<(ostream &os, const modInt<mod> &n) {
  return os << n.v;
};
template <int mod> modInt<mod> operator+(const ll &n, const modInt<mod> &m) {
  return m.v + n < mod ? m.v + n : m.v + n - mod;
}
template <int mod> modInt<mod> operator-(const ll &n, const modInt<mod> &m) {
  return n - m.v < 0 ? n - m.v + mod : n - m.v;
}
template <int mod> modInt<mod> operator*(const ll &n, const modInt<mod> &m) {
  return ll(m.v) * (n % mod) % mod;
}
template <int mod> modInt<mod> operator/(const ll &n, const modInt<mod> &m) {
  return ll(m.v) * modpow(n % mod, -1, mod) % mod;
}
typedef modInt<MOD> mint;
template <int mod> modInt<mod> modpow(modInt<mod> r, ll n) {
  modInt<mod> re(1);
  if (n < 0)
    (n %= mod - 1) += mod - 1;
  for (; n; n /= 2) {
    if (n & 1)
      re *= r;
    r *= r;
  }
  return re;
}
vector<mint> fact, finv, inv;
mint comb(ll n, ll r) {
  if (n < r || r < 0)
    return 0;
  return fact[n] * finv[n - r] * finv[r];
}
class Doralion {
  void Modinvs(vector<mint> &re, int n) {
    re.resize(n + 1);
    re[1] = 1;
    for (int i = 2; i <= n; ++i)
      re[i] = re[MOD % i] * (MOD - MOD / i);
  }
  void Facts(vector<mint> &re, int n) {
    re.resize(n + 1);
    re[0] = 1;
    rep(i, n) re[i + 1] = re[i] * (i + 1);
  }
  void Factinvs(vector<mint> &re, const vector<mint> &inv, int n) {
    re.resize(n + 1);
    re[0] = 1;
    rep(i, n) re[i + 1] = re[i] * inv[i + 1];
  }

public:
  Doralion(int n) {
    Modinvs(inv, n);
    Facts(fact, n);
    Factinvs(finv, inv, n);
  }
} doralion(212345);

mint dp[2][2222][2][2];

pair<vector<mint>, vector<mint>> fun(int n) {
  auto cur = dp[0];
  auto nxt = dp[1];
  fill(cur[0][0], cur[2222][0], 0);
  cur[0][1][0] = 1;
  rep(_, n) {
    fill(nxt[0][0], nxt[2222][0], 0);
    rep(i, n + 1) rep(j, 2) rep(k, 2) {
      nxt[i][k][0] += cur[i][j][k];
      nxt[i + 1][k][1] += cur[i][j][k];
      if (j == 0)
        nxt[i + 1][k][0] += cur[i][j][k];
    }
    swap(nxt, cur);
    // rep(i,5)
    // cout<<"("<<cur[i][0][0]<<","<<cur[i][0][1]<<","<<cur[i][1][0]<<","<<cur[i][1][1]<<")";cout<<endl;
  }
  vector<mint> re(n + 1);
  rep(i, n + 1) rep(j, 2) re[i] += cur[i][j][0];
  // rep(i,n+1) re[i]*=fact[n-i];
  vector<mint> pre(n + 1);
  rep(i, n + 1) rep(j, 2) pre[i] += nxt[i][j][0];
  // rep(i,n+1) pre[i]*=fact[n-i];
  return make_pair(re, pre);
}

int main() {
  ios_base::sync_with_stdio(false);
  cout << fixed << setprecision(0);
  int n, t;
  cin >> n >> t;
  vector<mint> v, w;
  int m = (n + t - 1) / t;
  tie(v, w) = fun(m);
  out(n, v, w, 1);
  vector<mint> dp{1};
  rep(i, t) {
    auto &f = ((n + i) / t == m ? v : w);
    vector<mint> nxt(dp.size() + f.size() - 1);
    rep(i, dp.size()) rep(j, f.size()) nxt[i + j] += dp[i] * f[j];
    dp = nxt;
    // out(dp,f,1);
  }
  rep(i, dp.size()) dp[i] *= fact[n - i];
  out(dp, 1);
  mint re = 0;
  rep(i, n + 1) re += dp[i] * (i % 2 ? MOD - 1 : 1);
  cout << re << endl;
  return 0;
}


Fixed submission:
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define X first
#define Y second
#define pb push_back
#define rep(X, Y) for (int(X) = 0; (X) < (Y); ++(X))
#define reps(X, S, Y) for (int(X) = S; (X) < (Y); ++(X))
#define rrep(X, Y) for (int(X) = (Y)-1; (X) >= 0; --(X))
#define rreps(X, S, Y) for (int(X) = (Y)-1; (X) >= (S); --(X))
#define repe(X, Y) for ((X) = 0; (X) < (Y); ++(X))
#define peat(X, Y) for (; (X) < (Y); ++(X))
#define all(X) (X).begin(), (X).end()
#define rall(X) (X).rbegin(), (X).rend()
#define eb emplace_back
#define UNIQUE(X) (X).erase(unique(all(X)), (X).end())
#define Endl endl

using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
template <class T> using vv = vector<vector<T>>;
template <class T> ostream &operator<<(ostream &os, const vector<T> &t) {
  os << "{";
  rep(i, t.size()) { os << t[i] << ","; }
  os << "}" << endl;
  return os;
}
template <class T, size_t n>
ostream &operator<<(ostream &os, const array<T, n> &t) {
  os << "{";
  rep(i, n) { os << t[i] << ","; }
  os << "}" << endl;
  return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &t) {
  return os << "(" << t.first << "," << t.second << ")";
}
template <class S, class T, class U>
ostream &operator<<(ostream &os, const tuple<S, T, U> &t) {
  return os << "(" << get<0>(t) << "," << get<1>(t) << "," << get<2>(t) << ")";
}
template <class S, class T, class U, class V>
ostream &operator<<(ostream &os, const tuple<S, T, U, V> &t) {
  return os << "(" << get<0>(t) << "," << get<1>(t) << "," << get<2>(t) << ","
            << get<3>(t) << ")";
}
template <class T> inline bool MX(T &l, const T &r) {
  return l < r ? l = r, 1 : 0;
}
template <class T> inline bool MN(T &l, const T &r) {
  return l > r ? l = r, 1 : 0;
}
// #undef NUIP
#ifdef NUIP
#define out(args...)                                                           \
  {                                                                            \
    vector<string> a_r_g_s = s_p_l_i_t(#args, ',');                            \
    e_r_r(a_r_g_s.begin(), args);                                              \
  }
vector<string> s_p_l_i_t(const string &s, char c) {
  vector<string> v;
  int d = 0, f = 0;
  string t;
  for (char c : s) {
    if (!d && c == ',')
      v.pb(t), t = "";
    else
      t += c;
    if (c == '\"' || c == '\'')
      f ^= 1;
    if (!f && c == '(')
      ++d;
    if (!f && c == ')')
      --d;
  }
  v.pb(t);
  return move(v);
}
void e_r_r(vector<string>::iterator it) {}
template <typename T, typename... Args>
void e_r_r(vector<string>::iterator it, T a, Args... args) {
  if (*it == " 1" || *it == "1")
    cerr << endl;
  else
    cerr << it->substr((*it)[0] == ' ', it->length()) << " = " << a << ", ";
  e_r_r(++it, args...);
}
#else
#define out
#endif
template <typename T> vector<T> table(int n, T v) { return vector<T>(n, v); }
template <class... Args> auto table(int n, Args... args) {
  auto val = table(args...);
  return vector<decltype(val)>(n, move(val));
}
const ll MOD = 924844033;

ll modpow(ll r, ll n, ll m = MOD) {
  ll re = 1, d = r % m;
  if (n < 0)
    (n %= m - 1) += m - 1;
  for (; n; n /= 2) {
    if (n & 1)
      (re *= d) %= m;
    (d *= d) %= m;
  }
  return re;
}
template <int mod = MOD> struct modInt {
  int v;
  modInt(int v = 0) : v(v) {}
  modInt operator+(const modInt &n) {
    return v + n.v < mod ? v + n.v : v + n.v - mod;
  }
  modInt operator-(const modInt &n) {
    return v - n.v < 0 ? v - n.v + mod : v - n.v;
  }
  modInt operator*(const modInt &n) { return ll(v) * n.v % mod; }
  modInt operator/(const modInt &n) {
    return ll(v) * modpow(n.v % mod, -1, mod) % mod;
  }
  modInt operator+(const ll &n) { return v + n < mod ? v + n : v + n - mod; }
  modInt operator-(const ll &n) { return v - n < 0 ? v - n + mod : v - n; }
  modInt operator*(const ll &n) { return ll(v) * (n % mod) % mod; }
  modInt operator/(const ll &n) {
    return ll(v) * modpow(n % mod, -1, mod) % mod;
  }
  modInt &operator+=(const modInt &n) {
    v += n.v;
    if (v >= mod)
      v -= mod;
    return *this;
  }
  modInt &operator-=(const modInt &n) {
    v -= n.v;
    if (v < 0)
      v += mod;
    return *this;
  }
  modInt &operator*=(const modInt &n) {
    v = ll(v) * n.v % mod;
    return *this;
  }
  modInt &operator/=(const modInt &n) {
    v = ll(v) * modpow(n.v, -1, mod) % mod;
    return *this;
  }
  modInt &operator+=(const ll &n) {
    v += n;
    if (v >= mod)
      v -= mod;
    return *this;
  }
  modInt &operator-=(const ll &n) {
    v -= n;
    if (v < 0)
      v += mod;
    return *this;
  }
  modInt &operator*=(const ll &n) {
    v = ll(v) * n % mod;
    return *this;
  }
  modInt &operator/=(const ll &n) {
    v = ll(v) * modpow(n, -1, mod) % mod;
    return *this;
  }
};
template <int mod> ostream &operator<<(ostream &os, const modInt<mod> &n) {
  return os << n.v;
};
template <int mod> modInt<mod> operator+(const ll &n, const modInt<mod> &m) {
  return m.v + n < mod ? m.v + n : m.v + n - mod;
}
template <int mod> modInt<mod> operator-(const ll &n, const modInt<mod> &m) {
  return n - m.v < 0 ? n - m.v + mod : n - m.v;
}
template <int mod> modInt<mod> operator*(const ll &n, const modInt<mod> &m) {
  return ll(m.v) * (n % mod) % mod;
}
template <int mod> modInt<mod> operator/(const ll &n, const modInt<mod> &m) {
  return ll(m.v) * modpow(n % mod, -1, mod) % mod;
}
typedef modInt<MOD> mint;
template <int mod> modInt<mod> modpow(modInt<mod> r, ll n) {
  modInt<mod> re(1);
  if (n < 0)
    (n %= mod - 1) += mod - 1;
  for (; n; n /= 2) {
    if (n & 1)
      re *= r;
    r *= r;
  }
  return re;
}
vector<mint> fact, finv, inv;
mint comb(ll n, ll r) {
  if (n < r || r < 0)
    return 0;
  return fact[n] * finv[n - r] * finv[r];
}
class Doralion {
  void Modinvs(vector<mint> &re, int n) {
    re.resize(n + 1);
    re[1] = 1;
    for (int i = 2; i <= n; ++i)
      re[i] = re[MOD % i] * (MOD - MOD / i);
  }
  void Facts(vector<mint> &re, int n) {
    re.resize(n + 1);
    re[0] = 1;
    rep(i, n) re[i + 1] = re[i] * (i + 1);
  }
  void Factinvs(vector<mint> &re, const vector<mint> &inv, int n) {
    re.resize(n + 1);
    re[0] = 1;
    rep(i, n) re[i + 1] = re[i] * inv[i + 1];
  }

public:
  Doralion(int n) {
    Modinvs(inv, n);
    Facts(fact, n);
    Factinvs(finv, inv, n);
  }
} doralion(212345);

mint dp[2][2222][2][2];

pair<vector<mint>, vector<mint>> fun(int n) {
  auto cur = dp[0];
  auto nxt = dp[1];
  fill(cur[0][0], cur[2222][0], 0);
  cur[0][1][0] = 1;
  rep(_, n) {
    fill(nxt[0][0], nxt[2222][0], 0);
    rep(i, n + 1) rep(j, 2) rep(k, 2) {
      nxt[i][k][0] += cur[i][j][k];
      nxt[i + 1][k][1] += cur[i][j][k];
      if (j == 0)
        nxt[i + 1][k][0] += cur[i][j][k];
    }
    swap(nxt, cur);
    // rep(i,5)
    // cout<<"("<<cur[i][0][0]<<","<<cur[i][0][1]<<","<<cur[i][1][0]<<","<<cur[i][1][1]<<")";cout<<endl;
  }
  vector<mint> re(n + 1);
  rep(i, n + 1) rep(j, 2) re[i] += cur[i][j][0];
  // rep(i,n+1) re[i]*=fact[n-i];
  vector<mint> pre(n + 1);
  rep(i, n + 1) rep(j, 2) pre[i] += nxt[i][j][0];
  // rep(i,n+1) pre[i]*=fact[n-i];
  return make_pair(re, pre);
}

int main() {
  ios_base::sync_with_stdio(false);
  cout << fixed << setprecision(0);
  int n, t;
  cin >> n >> t;
  vector<mint> v, w;
  int m = (n + t - 1) / t;
  tie(v, w) = fun(m);
  out(n, v, w, 1);
  vector<mint> dp{1};
  rep(i, t) {
    auto &f = ((n + i) / t == m ? v : w);
    vector<mint> nxt(dp.size() + f.size() - 1);
    rep(i, dp.size()) rep(j, f.size()) nxt[i + j] += dp[i] * f[j];
    dp = nxt;
    // out(dp,f,1);
  }
  dp.resize(n + 1);
  rep(i, dp.size()) dp[i] *= fact[n - i];
  out(dp, 1);
  mint re = 0;
  rep(i, n + 1) re += dp[i] * (i % 2 ? MOD - 1 : 1);
  cout << re << endl;
  return 0;
}