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

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

#define rep(i, n) for (ll i = 0; i < (n); ++i)
using ll = int_fast64_t;
using pll = pair<ll, ll>;
constexpr ll INF = 1LL << 60;
constexpr ll MOD = 1e9 + 7;
template <class T> bool chmax(T &a, const T &b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T> bool chmin(T &a, const T &b) {
  if (a > b) {
    a = b;
    return 1;
  }
  return 0;
}
#if loc || local
template <class T> void dump(T &&t) { cerr << t << endl; }
template <class T, class... Ts> void dump(T &&h, Ts &&...t) {
  cerr << h << ", ";
  dump(forward<Ts>(t)...);
}
#else
void dump() {}
template <class T, class... Ts> void dump(T &&h, Ts &&...t) {}
#endif
template <class T> istream &operator>>(istream &is, vector<T> &v) {
  for (auto &elemnt : v)
    is >> elemnt;
  return is;
}
template <class T, class U> istream &operator>>(istream &is, pair<T, U> &p) {
  is >> p.first >> p.second;
  return is;
}
template <class T> ostream &operator<<(ostream &os, vector<T> const &v) {
  for (auto const &vi : v)
    os << vi << " ";
  return os;
}
template <class T, class U>
ostream &operator<<(ostream &os, pair<T, U> const &p) {
  os << p.first << "," << p.second;
  return os;
}
template <class T> vector<T> vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto vec(size_t a, Ts... ts) {
  return vector<decltype(vec<T>(ts...))>(a, vec<T>(ts...));
}
template <int64_t MOD> struct mod_int {
  int64_t val;
  constexpr mod_int() : val(0) {}
  constexpr mod_int(int64_t x) noexcept
      : val(x >= 0 ? x % MOD : (MOD - (-x) % MOD) % MOD) {}
  constexpr int64_t value() const noexcept { return val; }
  constexpr int64_t get_MOD() const noexcept { return MOD; }
  constexpr mod_int operator+(mod_int const &rhs) {
    return mod_int(*this) += rhs;
  }
  constexpr mod_int operator-(mod_int const &rhs) {
    return mod_int(*this) -= rhs;
  }
  constexpr mod_int operator*(mod_int const &rhs) {
    return mod_int(*this) *= rhs;
  }
  constexpr mod_int operator/(mod_int const &rhs) {
    return mod_int(*this) /= rhs;
  }
  constexpr mod_int &operator+=(mod_int const &rhs) noexcept {
    val += rhs.val;
    if (val >= MOD)
      val -= MOD;
    return *this;
  }
  constexpr mod_int &operator-=(mod_int const &rhs) noexcept {
    if (val < rhs.val)
      val += MOD;
    val -= rhs.val;
    return *this;
  }
  constexpr mod_int &operator*=(mod_int const &rhs) noexcept {
    (val *= rhs.val) %= MOD;
    return *this;
  }
  constexpr mod_int &operator/=(mod_int rhs) noexcept {
    *this *= rhs.inverse();
    return *this;
  }
  constexpr bool operator==(mod_int const &rhs) const { return val == rhs.val; }
  constexpr bool operator!=(mod_int const &rhs) const {
    return !(val == rhs.val);
  }
  constexpr bool operator<(mod_int const &rhs) const { return val < rhs.val; }
  constexpr bool operator>(mod_int const &rhs) const { return val > rhs.val; }
  constexpr bool operator<=(mod_int const &rhs) const {
    return !(val > rhs.val);
  }
  constexpr bool operator>=(mod_int const &rhs) const {
    return !(val < rhs.val);
  }
  constexpr friend std::ostream &operator<<(std::ostream &os,
                                            mod_int const &mi) {
    return os << mi.val;
  }
  constexpr friend std::istream &operator>>(std::istream &is, mod_int &mi) {
    int64_t t = 0;
    is >> t;
    mi = mod_int<MOD>(t);
    return is;
  }
  constexpr mod_int inverse() {
    int64_t a = val, b = MOD, u = 1, v = 0, t = 0;
    while (b > 0) {
      t = a / b;
      std::swap(a -= t * b, b);
      std::swap(u -= t * v, v);
    }
    return mod_int(u);
  }
  constexpr mod_int mpow(int64_t n) const {
    mod_int res(1), e(*this);
    while (n) {
      if (n & 1)
        res *= e;
      e *= e;
      n >>= 1;
    }
    return res;
  }
};
using mint = mod_int<1000000007>;
mint mpow(int64_t p, int64_t n) {
  mint res = 1;
  mint e = p;
  while (n) {
    if (n & 1)
      res *= e;
    e *= e;
    n >>= 1;
  }
  return res;
}

struct combination {
  using i64 = int64_t;
  static constexpr i64 COM_MAX = 2e6;
  static constexpr i64 MOD = 1e9 + 7;
  vector<i64> fac, inv, finv;
  combination() {
    fac.resize(COM_MAX);
    inv.resize(COM_MAX);
    finv.resize(COM_MAX);
    fac[0] = fac[1] = 1;
    inv[1] = 1;
    finv[0] = finv[1] = 1;
    for (int i = 2; i < COM_MAX; ++i) {
      fac[i] = fac[i - 1] * i % MOD;
      inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
      finv[i] = finv[i - 1] * inv[i] % MOD;
    }
  }
  template <class T> mint nCk(T n, T k) {
    if (n < k)
      return 0;
    if (n < 0 || k < 0)
      return 0;
    if (n >= COM_MAX) {
      mint res1 = mint(1);
      mint res2 = mint(fac[k]);
      for (int i = 1; i <= k; ++i) {
        res1 *= n - (i - 1);
      }
      return res1 / res2;
    }
    return mint(fac[n] * (finv[k] * finv[n - k] % MOD));
  }
  template <class T> mint nHk(T n, T k) { return nCk(n + k - 1, k - 1); }
  template <class T> mint operator()(T n, T k) { return nCk(n, k); }
};

signed main() {

  int n, k;
  cin >> n >> k;
  vector<ll> a(n);
  cin >> a;

  if (n == k) {
    mint ans = 1;
    rep(i, n) ans *= a[i];
    cout << ans << endl;
    return 0;
  }
  if (all_of(begin(a), end(a), [](auto ai) { return ai <= 0; }) && (k & 1)) {
    sort(begin(a), end(a), [](auto a, auto b) { return abs(a) < abs(b); });
    mint ans = 1;
    rep(i, k) ans *= a[i];
    cout << ans << endl;
    return 0;
  }

  sort(begin(a), end(a), [](auto a, auto b) { return abs(a) > abs(b); });
  mint ans = 1;
  int t = 0;
  rep(i, k) {
    ans *= a[i];
    if (a[i] < 0)
      t ^= 1;
  }
  if (t == 0) {
    cout << ans << endl;
    return 0;
  }
  bool fa, fb, fc, fd;
  fa = fb = fc = fd = false;
  ll aa, bb, cc, dd;
  for (int i = k; i < n; ++i)
    if (a[i] > 0) {
      aa = a[i];
      fa = true;
      break;
    }
  for (int i = k; i < n; ++i)
    if (a[i] < 0) {
      bb = a[i];
      fb = true;
      break;
    }
  for (int i = k; i-- > 0;)
    if (a[i] > 0) {
      cc = a[i];
      fc = true;
      break;
    }
  for (int i = k; i-- > 0;)
    if (a[i] < 0) {
      dd = a[i];
      fd = true;
      break;
    }
  dump(fa, fb, fc, fd);
  dump(aa, bb, cc, dd);
  // a/d b/c <-> ac bd
  if (fa && fb && fc && fd) {
    auto f = [](auto a, auto b) -> __int128_t {
      __int128_t aa = a;
      __int128_t bb = b;
      return abs(a * b);
    };
    if (f(aa, cc) > f(bb, dd)) {
      ans /= dd;
      ans *= aa;
    } else {
      ans /= cc;
      ans *= bb;
    }
  } else if (fa && fd) {
    ans /= dd;
    ans *= aa;
  } else if (fb && fc) {
    ans /= cc;
    ans *= bb;
  } else {
    sort(begin(a), end(a), [](auto a, auto b) { return abs(a) < abs(b); });
    ans = 1;
    rep(i, k) ans *= a[i];
  }
  cout << (ans) << endl;
}

Error: 0

Fixed submission:

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

#define rep(i, n) for (ll i = 0; i < (n); ++i)
using ll = int_fast64_t;
using pll = pair<ll, ll>;
constexpr ll INF = 1LL << 60;
constexpr ll MOD = 1e9 + 7;
template <class T> bool chmax(T &a, const T &b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T> bool chmin(T &a, const T &b) {
  if (a > b) {
    a = b;
    return 1;
  }
  return 0;
}
#if loc || local
template <class T> void dump(T &&t) { cerr << t << endl; }
template <class T, class... Ts> void dump(T &&h, Ts &&...t) {
  cerr << h << ", ";
  dump(forward<Ts>(t)...);
}
#else
void dump() {}
template <class T, class... Ts> void dump(T &&h, Ts &&...t) {}
#endif
template <class T> istream &operator>>(istream &is, vector<T> &v) {
  for (auto &elemnt : v)
    is >> elemnt;
  return is;
}
template <class T, class U> istream &operator>>(istream &is, pair<T, U> &p) {
  is >> p.first >> p.second;
  return is;
}
template <class T> ostream &operator<<(ostream &os, vector<T> const &v) {
  for (auto const &vi : v)
    os << vi << " ";
  return os;
}
template <class T, class U>
ostream &operator<<(ostream &os, pair<T, U> const &p) {
  os << p.first << "," << p.second;
  return os;
}
template <class T> vector<T> vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto vec(size_t a, Ts... ts) {
  return vector<decltype(vec<T>(ts...))>(a, vec<T>(ts...));
}
template <int64_t MOD> struct mod_int {
  int64_t val;
  constexpr mod_int() : val(0) {}
  constexpr mod_int(int64_t x) noexcept
      : val(x >= 0 ? x % MOD : (MOD - (-x) % MOD) % MOD) {}
  constexpr int64_t value() const noexcept { return val; }
  constexpr int64_t get_MOD() const noexcept { return MOD; }
  constexpr mod_int operator+(mod_int const &rhs) {
    return mod_int(*this) += rhs;
  }
  constexpr mod_int operator-(mod_int const &rhs) {
    return mod_int(*this) -= rhs;
  }
  constexpr mod_int operator*(mod_int const &rhs) {
    return mod_int(*this) *= rhs;
  }
  constexpr mod_int operator/(mod_int const &rhs) {
    return mod_int(*this) /= rhs;
  }
  constexpr mod_int &operator+=(mod_int const &rhs) noexcept {
    val += rhs.val;
    if (val >= MOD)
      val -= MOD;
    return *this;
  }
  constexpr mod_int &operator-=(mod_int const &rhs) noexcept {
    if (val < rhs.val)
      val += MOD;
    val -= rhs.val;
    return *this;
  }
  constexpr mod_int &operator*=(mod_int const &rhs) noexcept {
    (val *= rhs.val) %= MOD;
    return *this;
  }
  constexpr mod_int &operator/=(mod_int rhs) noexcept {
    *this *= rhs.inverse();
    return *this;
  }
  constexpr bool operator==(mod_int const &rhs) const { return val == rhs.val; }
  constexpr bool operator!=(mod_int const &rhs) const {
    return !(val == rhs.val);
  }
  constexpr bool operator<(mod_int const &rhs) const { return val < rhs.val; }
  constexpr bool operator>(mod_int const &rhs) const { return val > rhs.val; }
  constexpr bool operator<=(mod_int const &rhs) const {
    return !(val > rhs.val);
  }
  constexpr bool operator>=(mod_int const &rhs) const {
    return !(val < rhs.val);
  }
  constexpr friend std::ostream &operator<<(std::ostream &os,
                                            mod_int const &mi) {
    return os << mi.val;
  }
  constexpr friend std::istream &operator>>(std::istream &is, mod_int &mi) {
    int64_t t = 0;
    is >> t;
    mi = mod_int<MOD>(t);
    return is;
  }
  constexpr mod_int inverse() {
    int64_t a = val, b = MOD, u = 1, v = 0, t = 0;
    while (b > 0) {
      t = a / b;
      std::swap(a -= t * b, b);
      std::swap(u -= t * v, v);
    }
    return mod_int(u);
  }
  constexpr mod_int mpow(int64_t n) const {
    mod_int res(1), e(*this);
    while (n) {
      if (n & 1)
        res *= e;
      e *= e;
      n >>= 1;
    }
    return res;
  }
};
using mint = mod_int<1000000007>;
mint mpow(int64_t p, int64_t n) {
  mint res = 1;
  mint e = p;
  while (n) {
    if (n & 1)
      res *= e;
    e *= e;
    n >>= 1;
  }
  return res;
}

struct combination {
  using i64 = int64_t;
  static constexpr i64 COM_MAX = 2e6;
  static constexpr i64 MOD = 1e9 + 7;
  vector<i64> fac, inv, finv;
  combination() {
    fac.resize(COM_MAX);
    inv.resize(COM_MAX);
    finv.resize(COM_MAX);
    fac[0] = fac[1] = 1;
    inv[1] = 1;
    finv[0] = finv[1] = 1;
    for (int i = 2; i < COM_MAX; ++i) {
      fac[i] = fac[i - 1] * i % MOD;
      inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
      finv[i] = finv[i - 1] * inv[i] % MOD;
    }
  }
  template <class T> mint nCk(T n, T k) {
    if (n < k)
      return 0;
    if (n < 0 || k < 0)
      return 0;
    if (n >= COM_MAX) {
      mint res1 = mint(1);
      mint res2 = mint(fac[k]);
      for (int i = 1; i <= k; ++i) {
        res1 *= n - (i - 1);
      }
      return res1 / res2;
    }
    return mint(fac[n] * (finv[k] * finv[n - k] % MOD));
  }
  template <class T> mint nHk(T n, T k) { return nCk(n + k - 1, k - 1); }
  template <class T> mint operator()(T n, T k) { return nCk(n, k); }
};

signed main() {

  int n, k;
  cin >> n >> k;
  vector<ll> a(n);
  cin >> a;

  if (n == k) {
    mint ans = 1;
    rep(i, n) ans *= a[i];
    cout << ans << endl;
    return 1;
  }
  if (all_of(begin(a), end(a), [](auto ai) { return ai <= 0; }) && (k & 1)) {
    sort(begin(a), end(a), [](auto a, auto b) { return abs(a) < abs(b); });
    mint ans = 1;
    rep(i, k) ans *= a[i];
    cout << ans << endl;
    return 0;
  }

  sort(begin(a), end(a), [](auto a, auto b) { return abs(a) > abs(b); });
  mint ans = 1;
  int t = 0;
  rep(i, k) {
    ans *= abs(a[i]);
    if (a[i] < 0)
      t ^= 1;
  }
  if (t == 0) {
    cout << ans << endl;
    return 0;
  }
  bool fa, fb, fc, fd;
  fa = fb = fc = fd = false;
  ll aa, bb, cc, dd;
  for (int i = k; i < n; ++i)
    if (a[i] > 0) {
      aa = a[i];
      fa = true;
      break;
    }
  for (int i = k; i < n; ++i)
    if (a[i] < 0) {
      bb = a[i];
      fb = true;
      break;
    }
  for (int i = k; i-- > 0;)
    if (a[i] > 0) {
      cc = a[i];
      fc = true;
      break;
    }
  for (int i = k; i-- > 0;)
    if (a[i] < 0) {
      dd = a[i];
      fd = true;
      break;
    }
  // a/d b/c <-> ac bd
  if (fa && fb && fc && fd) {
    auto f = [](auto a, auto b) -> __int128_t {
      __int128_t aa = a;
      __int128_t bb = b;
      return a * b;
    };
    if (f(aa, cc) > f(bb, dd)) {
      ans /= dd;
      ans *= aa;
    } else {
      ans /= cc;
      ans *= bb;
    }
  } else if (fa && fd) {
    ans /= dd;
    ans *= aa;
  } else if (fb && fc) {
    ans /= cc;
    ans *= bb;
  } else {
    sort(begin(a), end(a), [](auto a, auto b) { return abs(a) < abs(b); });
    ans = 1;
    rep(i, k) ans *= a[i];
  }
  cout << (ans) << endl;
}