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

/* winners never quit and quitters never win.
      #swap                                 */

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#pragma GCC optimize("-O3")
using ll = long long;
using ld = long double;
const ll mod = 1000000007;
const ll inf = 1000000000000000000;
const ll rk = 256;
const ld PI = 3.141592653589793;

typedef tree<int, null_type, less<int>, rb_tree_tag,
             tree_order_statistics_node_update>
    ordered_set;

template <typename T> void make_unique(vector<T> &vec) {
  sort(all(vec));
  vec.erase(unique(all(vec)), vec.end());
}

#define pb push_back
#define mp make_pair
#define vc vector
#define fs first
#define sec second
#define pq priority_queue
#define lb lower_bound
#define ub upper_bound
#define pll pair<ll, ll>
#define pls pair<ll, string>
#define psl pair<string, ll>
#define plc pair<ll, char>
#define pcl pair<char, ll>
#define pss pair<string, string>
#define all(x) (x).begin(), (x).end()
#define tol(s) transform(s.begin(), s.end(), s.begin(), ::tolower);
#define tou(s) transform(s.begin(), s.end(), s.begin(), ::toupper);
#define printclock                                                             \\
  cerr << "Time : " << 1000 * (ld)clock() / (ld)CLOCKS_PER_SEC << "ms\\n";

#define error(args...)                                                         \\
  {                                                                            \\
    string _s = #args;                                                         \\
    replace(_s.begin(), _s.end(), ',', ' ');                                   \\
    stringstream _ss(_s);                                                      \\
    istream_iterator<string> _it(_ss);                                         \\
    err(_it, args);                                                            \\
  }

void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
  cerr << *it << " = " << a << endl;
  err(++it, args...);
}

#define rep(i, begin, end)                                                     \\
  for (__typeof(end) i = (begin) - ((begin) > (end));                          \\
       i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define T                                                                      \\
  ll t = 0;                                                                    \\
  cin >> t;                                                                    \\
  for (ll test = 0; test < t; test++)

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

ll nxt() {
  ll TemporaryVariable;
  cin >> TemporaryVariable;
  return TemporaryVariable;
}

struct custom_hash {
  static uint64_t splitmix64(uint64_t x) {
    // http://xorshift.di.unimi.it/splitmix64.c
    x += 0x9e3779b97f4a7c15;
    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
    x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
    return x ^ (x >> 31);
  }

  size_t operator()(uint64_t x) const {
    static const uint64_t FIXED_RANDOM =
        chrono::steady_clock::now().time_since_epoch().count();
    return splitmix64(x + FIXED_RANDOM);
  }
};

ll fast_exp(ll base, ll exp1) {
  base %= mod;
  ll res = 1;
  while (exp1 > 0) {
    if (exp1 & 1)
      res = (res * base) % mod;
    base = (base * base) % mod;
    exp1 /= 2;
  }
  return res % mod;
}

ll add(ll x, ll y) { return (x + y + mod) % mod; }

ll mul(ll x, ll y) {
  while (x < 0)
    x += mod;
  while (y < 0)
    y += mod;
  return (x * y) % mod;
}

int32_t main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  // isprime();
  // coeff();
  /*freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);*/
  ll n = nxt(), k = nxt();
  vc<ll> v(n);
  generate(all(v), nxt);
  sort(all(v));
  ll ans = 1, last = n - 1;
  if (k % 2 == 1) {
    if (v[n - 1] <= 0) {
      ll p = n - 1;
      while (k) {
        ans = mul(ans, v[p]);
        k--;
        p--;
      }
      cout << ans << endl;
      exit(0);
    }
    ans = mul(ans, v[n - 1]);
    last--;
    k--;
  }
  ll start = 0;
  while (k) {
    ll p = v[last] * v[last - 1], q = v[start] * v[start + 1];
    if (q > p) {
      ans = mul(ans, mul(q, 1LL));
      start += 2;
    } else {
      ans = mul(ans, mul(p, 1LL));
      last -= 2;
    }
    k -= 2;
  }
  cout << ans << endl;
  printclock;
  return 0;
}


Error: 0

Fixed submission:

#include <bits/stdc++.h>

using namespace std;
#define ll long long int
#define mod 1000000007
int main() {
  ll t;
  t = 1;
  // cin >> t;
  while (t--) {
    ll n, k;
    cin >> n >> k;
    ll a[n];
    vector<int> pos, neg;

    for (int i = 0; i < n; i++) {
      cin >> a[i];
      if (a[i] >= 0)
        pos.push_back(a[i]);
      else
        neg.push_back(a[i]);
    }
    sort(pos.begin(), pos.end());
    sort(neg.begin(), neg.end());

    int i = pos.size() - 1;
    int j = neg.size() - 1;
    long long int ans = 1;
    while (k && i >= 0 && j >= 0) {
      ll x = 1, y = 1;
      if (pos[i] > abs(neg[j])) {
        ans = ((ans % mod) * pos[i]) % mod;
        i--;
        k--;
      } else {
        if (i >= 1 && j >= 1 && k >= 2) {
          x = neg[i] * neg[i - 1];
          y = pos[i] * pos[i - 1];
          if (x > y) {
            x %= mod;
            ans = ((ans % mod) * x) % mod;
            k -= 2;
            j -= 2;
          } else {
            ans = ((ans % mod) * pos[i]) % mod;
            i--;
            k--;
          }
        }
      }
    }
    if (k != 0) {
      if (i >= 0) {
        while (k--) {
          ans = ((ans % mod) * pos[i--]) % mod;
        }
      } else {
        if (k % 2 == 0 || (k + 1) > j + 1) {
          while (k--) {
            ans = ((ans % mod) * neg[j--]) % mod;
          }
        } else {
          ans = 1;
          i = 1;
          while (i < pos.size()) {
            ans = ((ans % mod) * pos[i++]) % mod;
          }

          j -= k;
          if (pos.size() == 0)
            j++;
          while (j < neg.size()) {
            ans = ((ans % mod) * neg[j++]) % mod;
          }
        }
      }
    }
    cout << (ans + mod) % mod << endl;
  }
}