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

#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdint>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;
using ll = long long;
using ull = unsigned long long;

namespace utils {
#define ALL(x) begin(x), end(x)
#define RALL(x) rbegin(x), rend(x)
template <class T, class Compare>
using p_queue = priority_queue<T, vector<T>, Compare>;
template <class T> using min_queue = p_queue<T, greater<T>>;
template <class T> using max_queue = p_queue<T, less<T>>;

template <class T> inline bool UPMIN(T &X, const T &A) {
  if (X > A) {
    X = A;
    return true;
  }
  return false;
}
template <class T> inline bool UPMAX(T &X, const T &A) {
  if (X < A) {
    X = A;
    return true;
  }
  return false;
}

template <class T> vector<T> VEC(int n, T t) { return vector<T>(n, t); }
template <class... Ts> auto VEC(int n, Ts... ts) {
  return vector<decltype(VEC(ts...))>(n, VEC(ts...));
}

template <class S, class T> istream &operator>>(istream &is, tuple<S, T> &t) {
  return is >> get<0>(t) >> get<1>(t);
}

template <class S, class T, class U>
istream &operator>>(istream &is, tuple<S, T, U> &t) {
  return is >> get<0>(t) >> get<1>(t) >> get<2>(t);
}

template <class S, class T>
ostream &operator<<(ostream &os, const tuple<S, T> &t) {
  return os << get<0>(t) << ' ' << get<1>(t);
}

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 T> istream &operator>>(istream &is, vector<T> &v) {
  for (auto &&x : v) {
    is >> x;
  }
  return is;
}

template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
  auto p = v.begin();
  assert(p != v.end());
  os << *p++;
  while (p != v.end()) {
    os << ' ' << *p++;
  }
  return os;
}

template <class T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
  auto p = v.begin();
  assert(p != v.end());
  os << *p++;
  while (p != v.end()) {
    os << '\\n' << *p++;
  }
  return os;
}

template <class... Ts>
ostream &operator<<(ostream &os, const vector<tuple<Ts...>> &v) {
  auto p = v.begin();
  assert(p != v.end());
  os << *p++;
  while (p != v.end()) {
    os << '\\n' << *p++;
  }
  return os;
}

constexpr long long INFLL = 1'000'000'000'000'000'000ll;
constexpr int INF = 1'000'000'000;
constexpr double PI = 3.14'159'265'358'973;
constexpr double EPS = 1e-10;
} // namespace utils
using namespace utils;

namespace xelm_ModInt {
class ModInt {
  static constexpr ll NIL = -1;
  static constexpr int64_t MOD = 1'000'000'007;
  //        static constexpr int64_t MOD = 998'244'353;

  ll val;

public:
  ModInt(ll x) : val(x >= 0 ? x % MOD : MOD - (-x) % MOD) {}
  ModInt(signed x) : val(x >= 0 ? x % MOD : MOD - (-x) % MOD) {}
  ModInt(ull x) : val(x % MOD) {}
  ModInt(unsigned x) : val(x % MOD) {}
  ModInt() : val{NIL} {}

  bool is_nil() { return val == NIL; }

  ModInt pow(ll n) const {
    ll r = 1, a = val;
    while (n) {
      if (n & 1) {
        r *= a;
        r %= MOD;
      }
      a *= a;
      a %= MOD;
      n /= 2;
    }
    return {r};
  }
  ModInt inv() const { /* return Inverse */
    assert(val != 0);
    return this->pow(MOD - 2);
  }

  void operator+=(const ModInt &a) {
    val += a.val;
    if (val >= MOD)
      val -= MOD;
  }
  void operator-=(const ModInt &a) {
    val -= a.val;
    if (val < 0)
      val += MOD;
  }
  void operator*=(const ModInt &a) {
    val *= a.val;
    val %= MOD;
  }
  void operator/=(const ModInt &a) {
    val *= a.inv().val;
    val %= MOD;
  }

  ModInt operator+(const ModInt &x) const {
    ll v = val + x.val;
    return {v};
  }
  ModInt operator-(const ModInt &x) const {
    ll v = val - x.val;
    return {v};
  }
  ModInt operator*(const ModInt &x) const {
    ll v = val * x.val;
    return {v};
  }
  ModInt operator/(const ModInt &x) const {
    ll v = val * x.inv().val;
    return {v};
  }

  bool operator==(const ModInt &x) const { return x.val == val; }
  bool operator!=(const ModInt &x) const { return x.val != val; }

  friend istream &operator>>(istream &is, ModInt &r) {
    ll tmp;
    is >> tmp;
    r = tmp;
    return is;
  }
  friend ostream &operator<<(ostream &os, const ModInt &r) {
    return os << r.val;
  }
};

ModInt fact(ll N) {
  /* N -> N! */
  static vector<ModInt> cal(1, ModInt{1});
  assert(N >= 0);

  if (cal.size() > N)
    return cal[N];
  else {
    ModInt nm = fact(N - 1);
    assert(cal.size() == N);
    cal.push_back(nm * N);
    return cal.back();
  }
}

/* N, k -> N C k */
ModInt choose(ll N, ll k) {
  // N! / k!(N-k!)
  ModInt ans = fact(N) / (fact(k) * fact(N - k));
  return ans;
}

ModInt operator"" _mod(unsigned long long x) { return ModInt{x}; }
} // namespace xelm_ModInt
using namespace xelm_ModInt;

class solver {
  istream &is;
  ostream &os;

public:
  solver(istream &I, ostream &O) : is(I), os(O) {}

  int N, K;
  vector<ll> Po, Ne;

  bool input() {
    is >> N >> K;
    for (int i = 0; i < N; ++i) {
      ll a;
      is >> a;
      if (a >= 0)
        Po.push_back(a);
      else
        Ne.push_back(a);
    } // end i
    sort(RALL(Po));
    sort(ALL(Ne));
    return !!is;
  }

  void run();
};

int main(int argc, char *argv[]) {
  cin.tie(nullptr);
  ios::sync_with_stdio(false);
  cout << setprecision(16) << scientific;
#ifdef XELMH
  string test_cases = "test_E.txt";
  cerr << test_cases << " -->" << endl;
  auto fs = fstream(test_cases, fstream::in);
  int loop = 0;
  while (fs) {
    loop++;
    cout << '#' << loop << "#------\\n";
    solver(fs, cout).run();
  }
  if (loop <= 1) {
    cout << "===" << endl;
    while (cin)
      solver(cin, cout).run();
  }
#else
  solver(cin, cout).run();
#endif
  return 0;
}

void solver::run() {
  if (!input())
    return;
  ModInt ans = 1;
  if (K == N) {
    for (int i = 0; i < Po.size(); ++i) {
      ans *= Po[i];
    } // end i
    for (auto &&x : Ne) {
      ans *= x;
    } // end x
    cout << ans << endl;
    return;
  }
  if (K % 2 == 1 and Po.empty()) {
    for (int i = 0; i < K; ++i) {
      ans *= Ne[Ne.size() - i - 1];
    } // end i
    cout << ans << endl;
    return;
  }
  int p, n;
  p = n = 0;

  while (K > 0) {
    if (K == 1) {
      ans *= Po[p];
      K--;
      break;
    } else {
      if (Ne.size() <= n + 1) {
        ans *= Po[p++];
        K--;
        continue;
      } else if (Po.size() <= p + 1) {
        ans *= Ne[n] * Ne[n + 1];
        n += 2;
        K -= 2;
        continue;
      } else {
        ll px = Po[p] * Po[p + 1];
        ll nx = Ne[n] * Ne[n + 1];
        if (px > nx) {
          ans *= Po[p];
          p++;
          K -= 1;
          continue;
        } else {
          ans *= nx;
          n += 2;
          K -= 2;
          continue;
        }
      }
    }
  }

  cout << ans << endl;
}


Error: WA

Fixed submission:

#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdint>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;
using ll = long long;
using ull = unsigned long long;

namespace utils {
#define ALL(x) begin(x), end(x)
#define RALL(x) rbegin(x), rend(x)
template <class T, class Compare>
using p_queue = priority_queue<T, vector<T>, Compare>;
template <class T> using min_queue = p_queue<T, greater<T>>;
template <class T> using max_queue = p_queue<T, less<T>>;

template <class T> inline bool UPMIN(T &X, const T &A) {
  if (X > A) {
    X = A;
    return true;
  }
  return false;
}
template <class T> inline bool UPMAX(T &X, const T &A) {
  if (X < A) {
    X = A;
    return true;
  }
  return false;
}

template <class T> vector<T> VEC(int n, T t) { return vector<T>(n, t); }
template <class... Ts> auto VEC(int n, Ts... ts) {
  return vector<decltype(VEC(ts...))>(n, VEC(ts...));
}

template <class S, class T> istream &operator>>(istream &is, tuple<S, T> &t) {
  return is >> get<0>(t) >> get<1>(t);
}

template <class S, class T, class U>
istream &operator>>(istream &is, tuple<S, T, U> &t) {
  return is >> get<0>(t) >> get<1>(t) >> get<2>(t);
}

template <class S, class T>
ostream &operator<<(ostream &os, const tuple<S, T> &t) {
  return os << get<0>(t) << ' ' << get<1>(t);
}

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 T> istream &operator>>(istream &is, vector<T> &v) {
  for (auto &&x : v) {
    is >> x;
  }
  return is;
}

template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
  auto p = v.begin();
  assert(p != v.end());
  os << *p++;
  while (p != v.end()) {
    os << ' ' << *p++;
  }
  return os;
}

template <class T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
  auto p = v.begin();
  assert(p != v.end());
  os << *p++;
  while (p != v.end()) {
    os << '\\n' << *p++;
  }
  return os;
}

template <class... Ts>
ostream &operator<<(ostream &os, const vector<tuple<Ts...>> &v) {
  auto p = v.begin();
  assert(p != v.end());
  os << *p++;
  while (p != v.end()) {
    os << '\\n' << *p++;
  }
  return os;
}

constexpr long long INFLL = 1'000'000'000'000'000'000ll;
constexpr int INF = 1'000'000'000;
constexpr double PI = 3.14'159'265'358'973;
constexpr double EPS = 1e-10;
} // namespace utils
using namespace utils;

namespace xelm_ModInt {
class ModInt {
  static constexpr ll NIL = -1;
  static constexpr int64_t MOD = 1'000'000'007;
  //        static constexpr int64_t MOD = 998'244'353;

  ll val;

public:
  ModInt(ll x) : val(x >= 0 ? x % MOD : MOD - (-x) % MOD) {}
  ModInt(signed x) : val(x >= 0 ? x % MOD : MOD - (-x) % MOD) {}
  ModInt(ull x) : val(x % MOD) {}
  ModInt(unsigned x) : val(x % MOD) {}
  ModInt() : val{NIL} {}

  bool is_nil() { return val == NIL; }

  ModInt pow(ll n) const {
    ll r = 1, a = val;
    while (n) {
      if (n & 1) {
        r *= a;
        r %= MOD;
      }
      a *= a;
      a %= MOD;
      n /= 2;
    }
    return {r};
  }
  ModInt inv() const { /* return Inverse */
    assert(val != 0);
    return this->pow(MOD - 2);
  }

  void operator+=(const ModInt &a) {
    val += a.val;
    if (val >= MOD)
      val -= MOD;
  }
  void operator-=(const ModInt &a) {
    val -= a.val;
    if (val < 0)
      val += MOD;
  }
  void operator*=(const ModInt &a) {
    val *= a.val;
    val %= MOD;
  }
  void operator/=(const ModInt &a) {
    val *= a.inv().val;
    val %= MOD;
  }

  ModInt operator+(const ModInt &x) const {
    ll v = val + x.val;
    return {v};
  }
  ModInt operator-(const ModInt &x) const {
    ll v = val - x.val;
    return {v};
  }
  ModInt operator*(const ModInt &x) const {
    ll v = val * x.val;
    return {v};
  }
  ModInt operator/(const ModInt &x) const {
    ll v = val * x.inv().val;
    return {v};
  }

  bool operator==(const ModInt &x) const { return x.val == val; }
  bool operator!=(const ModInt &x) const { return x.val != val; }

  friend istream &operator>>(istream &is, ModInt &r) {
    ll tmp;
    is >> tmp;
    r = tmp;
    return is;
  }
  friend ostream &operator<<(ostream &os, const ModInt &r) {
    return os << r.val;
  }
};

ModInt fact(ll N) {
  /* N -> N! */
  static vector<ModInt> cal(1, ModInt{1});
  assert(N >= 0);

  if (cal.size() > N)
    return cal[N];
  else {
    ModInt nm = fact(N - 1);
    assert(cal.size() == N);
    cal.push_back(nm * N);
    return cal.back();
  }
}

/* N, k -> N C k */
ModInt choose(ll N, ll k) {
  // N! / k!(N-k!)
  ModInt ans = fact(N) / (fact(k) * fact(N - k));
  return ans;
}

ModInt operator"" _mod(unsigned long long x) { return ModInt{x}; }
} // namespace xelm_ModInt
using namespace xelm_ModInt;

class solver {
  istream &is;
  ostream &os;

public:
  solver(istream &I, ostream &O) : is(I), os(O) {}

  int N, K;
  vector<ll> Po, Ne;

  bool input() {
    is >> N >> K;
    for (int i = 0; i < N; ++i) {
      ll a;
      is >> a;
      if (a >= 0)
        Po.push_back(a);
      else
        Ne.push_back(a);
    } // end i
    sort(RALL(Po));
    sort(ALL(Ne));
    return !!is;
  }

  void run();
};

int main(int argc, char *argv[]) {
  cin.tie(nullptr);
  ios::sync_with_stdio(false);
  cout << setprecision(16) << scientific;
#ifdef XELMH
  string test_cases = "test_E.txt";
  cerr << test_cases << " -->" << endl;
  auto fs = fstream(test_cases, fstream::in);
  int loop = 0;
  while (fs) {
    loop++;
    cout << '#' << loop << "#------\\n";
    solver(fs, cout).run();
  }
  if (loop <= 1) {
    cout << "===" << endl;
    while (cin)
      solver(cin, cout).run();
  }
#else
  solver(cin, cout).run();
#endif
  return 0;
}

void solver::run() {
  if (!input())
    return;
  ModInt ans = 1;
  if (K == N) {
    for (int i = 0; i < Po.size(); ++i) {
      ans *= Po[i];
    } // end i
    for (auto &&x : Ne) {
      ans *= x;
    } // end x
    cout << ans << endl;
    return;
  }
  if (K % 2 == 1 and Po.empty()) {
    for (int i = 0; i < K; ++i) {
      ans *= Ne[Ne.size() - i - 1];
    } // end i
    cout << ans << endl;
    return;
  }
  int p, n;
  p = n = 0;

  while (K > 0) {
    if (K == 1) {
      ans *= Po[p];
      K--;
    } else {
      if (Ne.size() - n <= 2) {
        ans *= Po[p++];
        ans *= Po[p++];
      } else if (Po.size() - n <= 2) {
        ans *= Ne[n++];
        ans *= Ne[n++];
      } else {
        ll px = Po[p] * Po[p + 1];
        ll nx = Ne[n] * Ne[n + 1];
        if (px > nx) {
          ans *= px;
          p += 2;
        } else {
          ans *= nx;
          n += 2;
        }
      }
      K -= 2;
    }
  }

  cout << ans << endl;
}