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


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

// typedef
//------------------------------------------
using LL = int64_t;
using VL = vector<LL>;
using VVL = vector<VL>;
using VS = vector<string>;
using PLL = pair<LL, LL>;

// container util
//------------------------------------------
#define whole(f, x, ...)                                                       \\
  ([&](decltype((x)) whole) {                                                  \\
    return (f)(begin(whole), end(whole), ##__VA_ARGS__);                       \\
  })(x)
#define rwhole(f, x, ...)                                                      \\
  ([&](decltype((x)) whole) {                                                  \\
    return (f)(rbegin(whole), rend(whole), ##__VA_ARGS__);                     \\
  })(x)
#define EACH(i, c)                                                             \\
  for (decltype((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define ALL(x) ::std::begin(x), ::std::end(x)
#define RALL(x) ::std::rbegin(x), ::std::rend(x)
#define SORT(c) whole(sort, c)
#define RSORT(c) rwhole(sort, c)

// constant
//--------------------------------------------
constexpr double EPS = 1e-10;
constexpr double PI = 3.14159265358979323846;
constexpr int MOD = 1000000007;

// grid
//--------------------------------------------
VL dx = {0, 1, 0, -1};
VL dy = {1, 0, -1, 0};
VL dx2 = {-1, 0, 1, -1, 1, -1, 0, 1};
VL dy2 = {-1, -1, -1, 0, 0, 1, 1, 1};

// debug
//--------------------------------------------
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x)                                                               \\
  cerr << #x << " = " << (x) << " (L" << __LINE__ << ")"                       \\
       << " " << __FILE__ << endl;

// IO accelerate
//--------------------------------------------
struct InitIO {
  InitIO() {
    cin.tie(nullptr);
    ios_base::sync_with_stdio(false);
    cout << fixed << setprecision(30);
  }
} init_io;

// template
//--------------------------------------------
//  declaretion
template <typename T> istream &operator>>(istream &is, vector<T> &vec);
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p);
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec);
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &vv);
template <typename T> vector<T> make_v(size_t a);
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts);
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v);
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v);

// implementation
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
  for (T &x : vec)
    is >> x;
  return is;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
  os << p.first << "," << p.second;
  return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
  for (int i = 0; i < vec.size(); i++) {
    os << vec[i] << (i + 1 == vec.size() ? "" : "\\t");
  }
  return os;
}
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &vv) {
  for (int i = 0; i < vv.size(); ++i) {
    s << vv[i] << endl;
  }
  return s;
}

// 多重vector
// auto dp=make_v<int>(4,h,w) みたいに使える
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }

template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
  return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}

// 多重vectorのためのfill
// fill_v(dp,0) みたいに使える
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
  t = v;
}

template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
  for (auto &e : t)
    fill_v(e, v);
}

template <class T, class U> void chmax(T &a, U b) {
  if (a < b)
    a = b;
}
template <class T, class U> void chmin(T &a, U b) {
  if (b < a)
    a = b;
}
template <typename T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template <typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; }

// main code

// auto mod int
//
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
// const int MOD = 1000000007;
struct mint {
  LL x; // typedef long long LL;
  constexpr mint(LL x = 0) : x((x % MOD + MOD) % MOD) {}
  constexpr mint operator-() const { return mint(-x); }
  constexpr mint &operator+=(const mint &a) {
    if ((this->x += a.x) >= MOD)
      this->x -= MOD;
    return *this;
  }
  constexpr mint &operator-=(const mint &a) {
    if ((this->x += MOD - a.x) >= MOD)
      this->x -= MOD;
    return *this;
  }
  constexpr mint &operator*=(const mint &a) {
    (this->x *= a.x) %= MOD;
    return *this;
  }
  constexpr mint operator+(const mint &a) const {
    mint res(*this);
    return res += a;
  }
  constexpr mint operator-(const mint &a) const {
    mint res(*this);
    return res -= a;
  }
  constexpr mint operator*(const mint &a) const {
    mint res(*this);
    return res *= a;
  }
  constexpr mint pow(LL t) const {
    if (!t)
      return 1;
    mint a = pow(t >> 1);
    a *= a;
    if (t & 1)
      a *= *this;
    return a;
  }

  // for prime MOD
  constexpr mint inv() const { return pow(MOD - 2); }
  constexpr mint &operator/=(const mint &a) { return (*this) *= a.inv(); }
  constexpr mint operator/(const mint &a) const {
    mint res(*this);
    return res /= a;
  }

  constexpr bool operator==(const mint &a) const { return this->x == a.x; }
  constexpr bool operator!=(const mint &a) const { return this->x != a.x; }
  constexpr bool operator<(const mint &a) const { return this->x < a.x; }

  friend istream &operator>>(istream &is, mint &m) { return is >> m.x; }
  friend ostream &operator<<(ostream &os, const mint &m) { return os << m.x; }
};
typedef vector<mint> VM;
typedef vector<VM> VVM;

int main(int argc, char *argv[]) {
  LL n, k;
  cin >> n >> k;
  VL a(n);
  cin >> a;
  SORT(a);
  VL mn, pl;
  if (n == k) {
    mint ans = 1;
    for (int i = 0; i < n; i++) {
      ans *= a[i];
    }
    cout << ans << endl;
    return 0;
  }
  for (int i = 0; i < n; i++) {
    if (a[i] < 0) {
      mn.push_back(-a[i]);
    } else {
      pl.push_back(a[i]);
    }
  }
  RSORT(mn);
  RSORT(pl);
  mint ans = 1;
  LL ind_m = 0;
  LL ind_p = 0;
  if (pl.size() == 0) {
    if (k % 2 == 1) {
      for (int i = 0; i < k; i++) {
        ans *= mn[mn.size() - i - 1];
      }
      ans *= -1;
      cout << ans << endl;
      return 0;
    } else {
      for (int i = 0; i < k; i++) {
        ans *= mn[i];
      }
      cout << ans << endl;
      return 0;
    }
  }
  for (int i = 0; i < k; i++) {
    if (ind_m == mn.size()) {
      ans *= pl[ind_p];
      ind_p++;
    } else if (ind_p == pl.size()) {
      ans *= mn[ind_m];
      ind_m++;
    } else if (mn[ind_m] < pl[ind_p]) {
      ans *= pl[ind_p];
      ind_p++;
    } else {
      ans *= mn[ind_m];
      ind_m++;
    }
  }
  if (ind_m % 2 == 1) {
    if (ind_m == mn.size() or ind_p == 0) {
      ans /= mn[ind_m - 1];
      ans *= pl[ind_p];
    } else if (ind_p == pl.size()) {
      ans /= pl[ind_p - 1];
      ans *= mn[ind_m];
    } else {
      LL tmp = max(pl[ind_p] * pl[ind_p - 1], mn[ind_m] * mn[ind_m - 1]);
      ans /= mn[ind_m - 1] * pl[ind_p - 1];
      ans *= tmp;
    }
  }
  cout << ans << endl;
  return 0;
}

Error: 0

Fixed submission:

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

// typedef
//------------------------------------------
using LL = int64_t;
using VL = vector<LL>;
using VVL = vector<VL>;
using VS = vector<string>;
using PLL = pair<LL, LL>;

// container util
//------------------------------------------
#define whole(f, x, ...)                                                       \\
  ([&](decltype((x)) whole) {                                                  \\
    return (f)(begin(whole), end(whole), ##__VA_ARGS__);                       \\
  })(x)
#define rwhole(f, x, ...)                                                      \\
  ([&](decltype((x)) whole) {                                                  \\
    return (f)(rbegin(whole), rend(whole), ##__VA_ARGS__);                     \\
  })(x)
#define EACH(i, c)                                                             \\
  for (decltype((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define ALL(x) ::std::begin(x), ::std::end(x)
#define RALL(x) ::std::rbegin(x), ::std::rend(x)
#define SORT(c) whole(sort, c)
#define RSORT(c) rwhole(sort, c)

// constant
//--------------------------------------------
constexpr double EPS = 1e-10;
constexpr double PI = 3.14159265358979323846;
constexpr int MOD = 1000000007;

// grid
//--------------------------------------------
VL dx = {0, 1, 0, -1};
VL dy = {1, 0, -1, 0};
VL dx2 = {-1, 0, 1, -1, 1, -1, 0, 1};
VL dy2 = {-1, -1, -1, 0, 0, 1, 1, 1};

// debug
//--------------------------------------------
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x)                                                               \\
  cerr << #x << " = " << (x) << " (L" << __LINE__ << ")"                       \\
       << " " << __FILE__ << endl;

// IO accelerate
//--------------------------------------------
struct InitIO {
  InitIO() {
    cin.tie(nullptr);
    ios_base::sync_with_stdio(false);
    cout << fixed << setprecision(30);
  }
} init_io;

// template
//--------------------------------------------
//  declaretion
template <typename T> istream &operator>>(istream &is, vector<T> &vec);
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p);
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec);
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &vv);
template <typename T> vector<T> make_v(size_t a);
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts);
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v);
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v);

// implementation
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
  for (T &x : vec)
    is >> x;
  return is;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
  os << p.first << "," << p.second;
  return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
  for (int i = 0; i < vec.size(); i++) {
    os << vec[i] << (i + 1 == vec.size() ? "" : "\\t");
  }
  return os;
}
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &vv) {
  for (int i = 0; i < vv.size(); ++i) {
    s << vv[i] << endl;
  }
  return s;
}

// 多重vector
// auto dp=make_v<int>(4,h,w) みたいに使える
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }

template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
  return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}

// 多重vectorのためのfill
// fill_v(dp,0) みたいに使える
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
  t = v;
}

template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
  for (auto &e : t)
    fill_v(e, v);
}

template <class T, class U> void chmax(T &a, U b) {
  if (a < b)
    a = b;
}
template <class T, class U> void chmin(T &a, U b) {
  if (b < a)
    a = b;
}
template <typename T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template <typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; }

// main code

// auto mod int
//
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
// const int MOD = 1000000007;
struct mint {
  LL x; // typedef long long LL;
  constexpr mint(LL x = 0) : x((x % MOD + MOD) % MOD) {}
  constexpr mint operator-() const { return mint(-x); }
  constexpr mint &operator+=(const mint &a) {
    if ((this->x += a.x) >= MOD)
      this->x -= MOD;
    return *this;
  }
  constexpr mint &operator-=(const mint &a) {
    if ((this->x += MOD - a.x) >= MOD)
      this->x -= MOD;
    return *this;
  }
  constexpr mint &operator*=(const mint &a) {
    (this->x *= a.x) %= MOD;
    return *this;
  }
  constexpr mint operator+(const mint &a) const {
    mint res(*this);
    return res += a;
  }
  constexpr mint operator-(const mint &a) const {
    mint res(*this);
    return res -= a;
  }
  constexpr mint operator*(const mint &a) const {
    mint res(*this);
    return res *= a;
  }
  constexpr mint pow(LL t) const {
    if (!t)
      return 1;
    mint a = pow(t >> 1);
    a *= a;
    if (t & 1)
      a *= *this;
    return a;
  }

  // for prime MOD
  constexpr mint inv() const { return pow(MOD - 2); }
  constexpr mint &operator/=(const mint &a) { return (*this) *= a.inv(); }
  constexpr mint operator/(const mint &a) const {
    mint res(*this);
    return res /= a;
  }

  constexpr bool operator==(const mint &a) const { return this->x == a.x; }
  constexpr bool operator!=(const mint &a) const { return this->x != a.x; }
  constexpr bool operator<(const mint &a) const { return this->x < a.x; }

  friend istream &operator>>(istream &is, mint &m) { return is >> m.x; }
  friend ostream &operator<<(ostream &os, const mint &m) { return os << m.x; }
};
typedef vector<mint> VM;
typedef vector<VM> VVM;

int main(int argc, char *argv[]) {
  LL n, k;
  cin >> n >> k;
  VL a(n);
  cin >> a;
  SORT(a);
  VL mn, pl;
  if (n == k) {
    mint ans = 1;
    for (int i = 0; i < n; i++) {
      ans *= a[i];
    }
    cout << ans << endl;
    return 0;
  }
  for (int i = 0; i < n; i++) {
    if (a[i] < 0) {
      mn.push_back(-a[i]);
    } else {
      pl.push_back(a[i]);
    }
  }
  RSORT(mn);
  RSORT(pl);
  mint ans = 1;
  LL ind_m = 0;
  LL ind_p = 0;
  if (pl.size() == 0) {
    for (int i = 0; i < k; i++) {
      ans *= mn[mn.size() - i - 1];
    }
    ans *= -1;
    cout << ans << endl;
    return 0;
  }
  if (k % 2 == 1) {
    ans *= pl[0];
    ind_p = 1;
    k--;
  }
  for (int i = 0; i < k; i += 2) {
    if (ind_p >= pl.size() - 2) {
      ans *= mn[ind_m] * mn[ind_m + 1];
      ind_m += 2;
    } else if (ind_m >= mn.size() - 2) {
      ans *= pl[ind_p] * pl[ind_p + 1];
      ind_p += 2;
    } else {
      LL a = pl[ind_p] * pl[ind_p + 1];
      LL b = mn[ind_m] * mn[ind_m + 1];
      if (a > b) {
        ans *= a;
        ind_p += 2;
      } else {
        ans *= b;
        ind_m += 2;
      }
    }
  }
  cout << ans << endl;
  return 0;
}