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

//
// Created on 2020/07/05.
//

#include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset>    // bitset
#include <cctype>    // isupper, islower, isdigit, toupper, tolower
#include <cstdint>   // int64_t, int*_t
#include <cstdio>    // printf
#include <deque>     // deque
#include <iomanip>
#include <ios>
#include <iostream> // cout, endl, cin
#include <map>      // map
#include <math.h>
#include <numeric>
#include <queue>         // queue, priority_queue
#include <set>           // set
#include <stack>         // stack
#include <string>        // string, to_string, stoi
#include <tuple>         // tuple, make_tuple
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <utility>       // pair, make_pair
#include <vector>        // vector

#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
typedef long long ll;
using namespace std;
const long long LINF = 1e18;
const int INF = 1e9;
const int mod = 1e9 + 7;

struct mint {
  ll x; // typedef long long ll;
  mint(ll x = 0) : x((x % mod + mod) % mod) {}
  mint operator-() const { return mint(-x); }
  mint &operator+=(const mint a) {
    if ((x += a.x) >= mod)
      x -= mod;
    return *this;
  }
  mint &operator-=(const mint a) {
    if ((x += mod - a.x) >= mod)
      x -= mod;
    return *this;
  }
  mint &operator*=(const mint a) {
    (x *= a.x) %= mod;
    return *this;
  }
  mint operator+(const mint a) const {
    mint res(*this);
    return res += a;
  }
  mint operator-(const mint a) const {
    mint res(*this);
    return res -= a;
  }
  mint operator*(const mint a) const {
    mint res(*this);
    return res *= a;
  }
  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
  mint inv() const { return pow(mod - 2); }
  mint &operator/=(const mint a) { return (*this) *= a.inv(); }
  mint operator/(const mint a) const {
    mint res(*this);
    return res /= a;
  }
};

int main() {

  int n, k;
  cin >> n >> k;
  vector<ll> A(n);
  mint ans = 1;
  for (int i = 0; i < n; ++i) {
    cin >> A[i];
  }
  sort(rall(A));
  deque<ll> q_posi;
  deque<ll> q_nega;
  if (n == k) {
    for (int i = 0; i < n; ++i) {
      ans *= A[i];
    }
    cout << ans.x << endl;
    return 0;
  }
  int cnt = 0;
  if (A[0] > 0) {
    for (cnt = 0; cnt < n; ++cnt) {
      if (A[cnt] <= 0)
        break;
      q_posi.push_back(A[cnt]);
    }
  }
  for (cnt; cnt < n; ++cnt) {
    q_nega.push_back(A[cnt]);
  }

  if (q_posi.size() == 0 && k % 2 == 1) {
    while (k > 0) {
      ans *= q_nega.front();
      q_nega.pop_front();
      k--;
    }
  } else {
    while (k >= 2 && q_nega.size() >= 2) {
      ll posi_1 = 0;
      ll posi_2 = 0;
      if (q_posi.size() >= 2) {
        posi_1 = q_posi.front();
        q_posi.pop_front();
        posi_2 = q_posi.front();
        q_posi.pop_front();
        q_posi.push_front(posi_2);
        q_posi.push_front(posi_1);
      } else if (q_posi.size() == 1) {
        posi_1 = q_posi.front();
        q_posi.pop_front();
        posi_2 = 1;
      }
      ll nega_1 = 0;
      ll nega_2 = 0;
      if (q_nega.size() >= 2) {
        nega_1 = q_nega.back();
        q_nega.pop_back();
        nega_2 = q_nega.back();
        q_nega.pop_back();
        q_nega.push_back(nega_2);
        q_nega.push_back(nega_1);
      }
      if ((posi_1 * posi_2 > (nega_1 * nega_2))) {
        // posi>nega
        ans *= posi_1;
        q_posi.pop_front();
        k--;

      } else {
        ans *= nega_1;
        ans *= nega_2;
        q_nega.pop_back();
        q_nega.pop_back();
        k -= 2;
      }
    }

    while (k != 0) {
      if (!q_posi.empty()) {
        ans *= q_posi.front();
        q_posi.pop_front();
      } else {
        ans *= q_nega.front();
        q_nega.pop_front();
      }
      k--;
    }
  }

  cout << ans.x << endl;
  return 0;
}


Error: 0

Fixed submission:

//
// Created on 2020/07/05.
//

#include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset>    // bitset
#include <cctype>    // isupper, islower, isdigit, toupper, tolower
#include <cstdint>   // int64_t, int*_t
#include <cstdio>    // printf
#include <deque>     // deque
#include <iomanip>
#include <ios>
#include <iostream> // cout, endl, cin
#include <map>      // map
#include <math.h>
#include <numeric>
#include <queue>         // queue, priority_queue
#include <set>           // set
#include <stack>         // stack
#include <string>        // string, to_string, stoi
#include <tuple>         // tuple, make_tuple
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <utility>       // pair, make_pair
#include <vector>        // vector

#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
typedef long long ll;
using namespace std;
const long long LINF = 1e18;
const int INF = 1e9;
const int mod = 1e9 + 7;

struct mint {
  ll x; // typedef long long ll;
  mint(ll x = 0) : x((x % mod + mod) % mod) {}
  mint operator-() const { return mint(-x); }
  mint &operator+=(const mint a) {
    if ((x += a.x) >= mod)
      x -= mod;
    return *this;
  }
  mint &operator-=(const mint a) {
    if ((x += mod - a.x) >= mod)
      x -= mod;
    return *this;
  }
  mint &operator*=(const mint a) {
    (x *= a.x) %= mod;
    return *this;
  }
  mint operator+(const mint a) const {
    mint res(*this);
    return res += a;
  }
  mint operator-(const mint a) const {
    mint res(*this);
    return res -= a;
  }
  mint operator*(const mint a) const {
    mint res(*this);
    return res *= a;
  }
  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
  mint inv() const { return pow(mod - 2); }
  mint &operator/=(const mint a) { return (*this) *= a.inv(); }
  mint operator/(const mint a) const {
    mint res(*this);
    return res /= a;
  }
};

int main() {
  int n, k;
  cin >> n >> k;
  vector<ll> A(n);
  for (int i = 0; i < n; ++i) {
    cin >> A[i];
  }
  sort(rall(A));
  deque<ll> q;
  for (int j = 0; j < n; ++j) {
    q.push_back(A[j]);
  }
  mint ans = 1;
  if (q.front() < 0 && k % 2 == 1) {
    while (k > 0) {
      ans *= q.front();
      q.pop_front();
      k--;
    }
  } else {

    while (k >= 2) {
      ll posi_1 = q.front();
      q.pop_front();
      ll posi_2 = q.front();
      q.pop_front();
      ll nega_1 = q.back();
      q.pop_back();
      ll nega_2 = q.back();
      q.pop_back();
      if (abs(posi_1 / nega_2) >= abs(nega_1 / posi_2)) {
        // posi>nega
        ans *= posi_1;
        ans *= posi_2;
        q.push_back(nega_2);
        q.push_back(nega_1);
      } else {
        ans *= nega_1;
        ans *= nega_2;
        q.push_front(posi_1);
        q.push_front(posi_2);
      }
      k -= 2;
    }
    if (k > 0) {
      ans *= q.front();
    }
  }

  cout << ans.x << endl;
  return 0;
}