Problem p02635 (C++) — buggy submission, verdict: Runtime Error

#include <bits/stdc++.h>
#define FASTIO
using namespace std;

using ll = long long;
using Vi = vector<int>;
using Vl = vector<ll>;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;

constexpr int I_INF = numeric_limits<int>::max();
constexpr ll L_INF = numeric_limits<ll>::max();

//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

template <std::int_fast64_t Modulus> class ModInt {
  using i64 = std::int_fast64_t;

private:
  i64 m_value;

public:
  constexpr ModInt(const i64 x = 0) noexcept : m_value(x % Modulus) {
    if (m_value < 0)
      m_value += Modulus;
  }

  constexpr const i64 &value() const noexcept { return m_value; }

  constexpr ModInt &operator+=(const ModInt rhs) noexcept {
    m_value += rhs.m_value;
    if (m_value >= Modulus) {
      m_value -= Modulus;
    }
    return *this;
  }
  constexpr ModInt &operator-=(const ModInt rhs) noexcept {
    if (m_value < rhs.m_value) {
      m_value += Modulus;
    }
    m_value -= rhs.m_value;
    return *this;
  }
  constexpr ModInt &operator*=(const ModInt rhs) noexcept {
    m_value = m_value * rhs.m_value % Modulus;
    return *this;
  }
  constexpr ModInt &operator/=(ModInt rhs) noexcept {
    *this *= rhs.inv();
    return *this;
  }

  constexpr ModInt &operator++() noexcept {
    *this += 1;
    return *this;
  }
  constexpr ModInt operator++(int) noexcept {
    ModInt res = *this;
    *this += 1;
    return res;
  }
  constexpr ModInt &operator--() noexcept {
    *this -= 1;
    return *this;
  }
  constexpr ModInt operator--(int) noexcept {
    ModInt res = *this;
    *this -= 1;
    return res;
  }

  constexpr ModInt inv() const noexcept {
    i64 q = m_value;
    i64 b = Modulus, u = 1, v = 0;
    while (b) {
      i64 t = q / b;
      q -= t * b;
      std::swap(q, b);
      u -= t * v;
      std::swap(u, v);
    }
    u %= Modulus;
    if (u < 0)
      u += Modulus;
    return u;
  }

  constexpr ModInt pow(i64 k) const noexcept {
    ModInt res = 1;
    ModInt tmp;
    if (k < 0) {
      tmp = (*this).inv();
      k = -k;
    } else {
      tmp = *this;
    }
    for (; k > 0; k >>= 1) {
      if (k & 1)
        res *= tmp;
      tmp *= tmp;
    }
    return res;
  }

  friend constexpr ModInt operator+(const ModInt &lhs,
                                    const ModInt &rhs) noexcept {
    return ModInt<Modulus>(lhs) += rhs;
  }
  friend constexpr ModInt operator-(const ModInt &lhs,
                                    const ModInt &rhs) noexcept {
    return ModInt<Modulus>(lhs) -= rhs;
  }
  friend constexpr ModInt operator*(const ModInt &lhs,
                                    const ModInt &rhs) noexcept {
    return ModInt<Modulus>(lhs) *= rhs;
  }
  friend constexpr ModInt operator/(const ModInt &lhs,
                                    const ModInt &rhs) noexcept {
    return ModInt<Modulus>(lhs) /= rhs;
  }

  friend constexpr bool operator<(const ModInt &lhs,
                                  const ModInt &rhs) noexcept {
    return lhs.m_value < rhs.m_value;
  }
  friend constexpr bool operator>(const ModInt &lhs,
                                  const ModInt &rhs) noexcept {
    return lhs.m_value > rhs.m_value;
  }
  friend constexpr bool operator<=(const ModInt &lhs,
                                   const ModInt &rhs) noexcept {
    return lhs.m_value <= rhs.m_value;
  }
  friend constexpr bool operator>=(const ModInt &lhs,
                                   const ModInt &rhs) noexcept {
    return lhs.m_value >= rhs.m_value;
  }

  friend constexpr bool operator==(const ModInt &lhs,
                                   const ModInt &rhs) noexcept {
    return lhs.m_value == rhs.m_value;
  }
  friend constexpr bool operator!=(const ModInt &lhs,
                                   const ModInt &rhs) noexcept {
    return lhs.m_value != rhs.m_value;
  }

  friend std::istream &operator>>(std::istream &is, ModInt &rhs) {
    i64 a;
    is >> a;
    rhs = a;
    return is;
  }
  friend std::ostream &operator<<(std::ostream &os, const ModInt &rhs) {
    os << rhs.m_value;
    return os;
  }
};

constexpr ll MOD = 998244353;
using Mint = ModInt<MOD>;

Mint dp[310][310][310];

void solve() {
  string S;
  ll K;
  cin >> S >> K;
  Vi vec;
  ll cnt = 0;
  for (const auto &c : S) {
    if (c == '1') {
      ++cnt;
    } else {
      vec.emplace_back(cnt);
      cnt = 0;
    }
  }
  if (cnt) {
    vec.emplace_back(cnt);
  }

  reverse(vec.begin(), vec.end());

  ll n = (ll)vec.size();

  dp[0][0][0] = 1;
  for (ll i = 0; i < n; i++) {
    for (ll j = 0; j < 310; j++) {
      for (ll k = 0; k < 310; k++) {
        for (ll l = 0; l <= vec[i] + k; l++) {
          if (dp[i][j][k] != 0) {
            dp[i + 1][j + max(vec[i] - l, 0ll)][k + vec[i] - l] += dp[i][j][k];
          }
        }
      }
    }
  }

  Mint ans = 0;
  for (ll i = 0; i <= min(K, 300ll); i++) {
    ans += dp[n][i][0];
  }
  cout << ans << "\\n";
}

//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

int main() {
#ifdef FASTIO
  cin.tie(0), cout.tie(0);
  ios::sync_with_stdio(false);
#endif
#ifdef FILEINPUT
  ifstream ifs("./in_out/input.txt");
  cin.rdbuf(ifs.rdbuf());
#endif
#ifdef FILEOUTPUT
  ofstream ofs("./in_out/output.txt");
  cout.rdbuf(ofs.rdbuf());
#endif
  solve();
  cout << flush;
  return 0;
}

Error: -11

Fixed submission:

#include <bits/stdc++.h>
#define FASTIO
using namespace std;

using ll = long long;
using Vi = vector<int>;
using Vl = vector<ll>;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;

constexpr int I_INF = numeric_limits<int>::max();
constexpr ll L_INF = numeric_limits<ll>::max();

//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

template <std::int_fast64_t Modulus> class ModInt {
  using i64 = std::int_fast64_t;

private:
  i64 m_value;

public:
  constexpr ModInt(const i64 x = 0) noexcept : m_value(x % Modulus) {
    if (m_value < 0)
      m_value += Modulus;
  }

  constexpr const i64 &value() const noexcept { return m_value; }

  constexpr ModInt &operator+=(const ModInt rhs) noexcept {
    m_value += rhs.m_value;
    if (m_value >= Modulus) {
      m_value -= Modulus;
    }
    return *this;
  }
  constexpr ModInt &operator-=(const ModInt rhs) noexcept {
    if (m_value < rhs.m_value) {
      m_value += Modulus;
    }
    m_value -= rhs.m_value;
    return *this;
  }
  constexpr ModInt &operator*=(const ModInt rhs) noexcept {
    m_value = m_value * rhs.m_value % Modulus;
    return *this;
  }
  constexpr ModInt &operator/=(ModInt rhs) noexcept {
    *this *= rhs.inv();
    return *this;
  }

  constexpr ModInt &operator++() noexcept {
    *this += 1;
    return *this;
  }
  constexpr ModInt operator++(int) noexcept {
    ModInt res = *this;
    *this += 1;
    return res;
  }
  constexpr ModInt &operator--() noexcept {
    *this -= 1;
    return *this;
  }
  constexpr ModInt operator--(int) noexcept {
    ModInt res = *this;
    *this -= 1;
    return res;
  }

  constexpr ModInt inv() const noexcept {
    i64 q = m_value;
    i64 b = Modulus, u = 1, v = 0;
    while (b) {
      i64 t = q / b;
      q -= t * b;
      std::swap(q, b);
      u -= t * v;
      std::swap(u, v);
    }
    u %= Modulus;
    if (u < 0)
      u += Modulus;
    return u;
  }

  constexpr ModInt pow(i64 k) const noexcept {
    ModInt res = 1;
    ModInt tmp;
    if (k < 0) {
      tmp = (*this).inv();
      k = -k;
    } else {
      tmp = *this;
    }
    for (; k > 0; k >>= 1) {
      if (k & 1)
        res *= tmp;
      tmp *= tmp;
    }
    return res;
  }

  friend constexpr ModInt operator+(const ModInt &lhs,
                                    const ModInt &rhs) noexcept {
    return ModInt<Modulus>(lhs) += rhs;
  }
  friend constexpr ModInt operator-(const ModInt &lhs,
                                    const ModInt &rhs) noexcept {
    return ModInt<Modulus>(lhs) -= rhs;
  }
  friend constexpr ModInt operator*(const ModInt &lhs,
                                    const ModInt &rhs) noexcept {
    return ModInt<Modulus>(lhs) *= rhs;
  }
  friend constexpr ModInt operator/(const ModInt &lhs,
                                    const ModInt &rhs) noexcept {
    return ModInt<Modulus>(lhs) /= rhs;
  }

  friend constexpr bool operator<(const ModInt &lhs,
                                  const ModInt &rhs) noexcept {
    return lhs.m_value < rhs.m_value;
  }
  friend constexpr bool operator>(const ModInt &lhs,
                                  const ModInt &rhs) noexcept {
    return lhs.m_value > rhs.m_value;
  }
  friend constexpr bool operator<=(const ModInt &lhs,
                                   const ModInt &rhs) noexcept {
    return lhs.m_value <= rhs.m_value;
  }
  friend constexpr bool operator>=(const ModInt &lhs,
                                   const ModInt &rhs) noexcept {
    return lhs.m_value >= rhs.m_value;
  }

  friend constexpr bool operator==(const ModInt &lhs,
                                   const ModInt &rhs) noexcept {
    return lhs.m_value == rhs.m_value;
  }
  friend constexpr bool operator!=(const ModInt &lhs,
                                   const ModInt &rhs) noexcept {
    return lhs.m_value != rhs.m_value;
  }

  friend std::istream &operator>>(std::istream &is, ModInt &rhs) {
    i64 a;
    is >> a;
    rhs = a;
    return is;
  }
  friend std::ostream &operator<<(std::ostream &os, const ModInt &rhs) {
    os << rhs.m_value;
    return os;
  }
};

constexpr ll MOD = 998244353;
using Mint = ModInt<MOD>;

Mint dp[310][310][310];

void solve() {
  string S;
  ll K;
  cin >> S >> K;
  Vi vec;
  ll cnt = 0;
  for (const auto &c : S) {
    if (c == '1') {
      ++cnt;
    } else {
      vec.emplace_back(cnt);
      cnt = 0;
    }
  }
  if (cnt) {
    vec.emplace_back(cnt);
  }

  reverse(vec.begin(), vec.end());

  ll n = (ll)vec.size();

  dp[0][0][0] = 1;
  for (ll i = 0; i < n; i++) {
    for (ll j = 0; j < 310; j++) {
      for (ll k = 0; k < 310; k++) {
        for (ll l = 0; l <= vec[i] + k; l++) {
          if (j + vec[i] - l >= 0 && dp[i][j][k] != 0) {
            dp[i + 1][j + max(vec[i] - l, 0ll)][k + vec[i] - l] += dp[i][j][k];
          }
        }
      }
    }
  }

  Mint ans = 0;
  for (ll i = 0; i <= K; i++) {
    ans += dp[n][i][0];
  }
  cout << ans << "\\n";
}

//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

int main() {
#ifdef FASTIO
  cin.tie(0), cout.tie(0);
  ios::sync_with_stdio(false);
#endif
#ifdef FILEINPUT
  ifstream ifs("./in_out/input.txt");
  cin.rdbuf(ifs.rdbuf());
#endif
#ifdef FILEOUTPUT
  ofstream ofs("./in_out/output.txt");
  cout.rdbuf(ofs.rdbuf());
#endif
  solve();
  cout << flush;
  return 0;
}