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

#include <bits/stdc++.h>
#include <sys/types.h>
#include <unistd.h>

#define _overload(_1, _2, _3, name, ...) name
#define _rep(i, n) _range(i, 0, n)
#define _range(i, a, b) for (int i = int(a); i < int(b); ++i)
#define rep(...) _overload(__VA_ARGS__, _range, _rep, )(__VA_ARGS__)

#define _rrep(i, n) _rrange(i, n, 0)
#define _rrange(i, a, b) for (int i = int(a) - 1; i >= int(b); --i)
#define rrep(...) _overload(__VA_ARGS__, _rrange, _rrep, )(__VA_ARGS__)

#define _all(arg) begin(arg), end(arg)
#define uniq(arg) sort(_all(arg)), (arg).erase(unique(_all(arg)), end(arg))
#define getidx(ary, key) lower_bound(_all(ary), key) - begin(ary)
#define clr(a, b) memset((a), (b), sizeof(a))
#define bit(n) (1LL << (n))
#define popcount(n) (__builtin_popcountll(n))

using namespace std;

template <class T> bool chmax(T &a, const T &b) {
  return (a < b) ? (a = b, 1) : 0;
}
template <class T> bool chmin(T &a, const T &b) {
  return (b < a) ? (a = b, 1) : 0;
}

using ll = long long;
using R = long double;
const R EPS = 1e-9L; // [-1000,1000]->EPS=1e-8 [-10000,10000]->EPS=1e-7
inline int sgn(const R &r) { return (r > EPS) - (r < -EPS); }
inline R sq(R x) { return sqrt(max(x, 0.0L)); }

template <typename T> vector<T> make_vector(size_t sz) { return vector<T>(sz); }

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

template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value != 0>::type fill_value(U &u,
                                                               const V... v) {
  u = U(v...);
}

template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value == 0>::type fill_value(U &u,
                                                               const V... v) {
  for (auto &e : u) {
    fill_value<T>(e, v...);
  }
}

const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};

const pid_t pid = getpid();
// Problem Specific Parameter:

const int CONTEST_TYPE = 26;
int D;
int c[CONTEST_TYPE], s[365][CONTEST_TYPE];

using state = struct {
  set<int> held_days[CONTEST_TYPE];
  int type[365];
  int score;
};

void input() {
  cin >> D;

  rep(i, CONTEST_TYPE) { cin >> c[i]; }

  rep(i, D) rep(j, CONTEST_TYPE) { cin >> s[i][j]; }
}

state calc_init(const vector<int> &type) {
  const int DAY = type.size();
  vector<int> last(CONTEST_TYPE, 0);

  state ret;
  ret.score = 0;

  rep(j, CONTEST_TYPE) {
    ret.held_days[j].insert(0);
    ret.held_days[j].insert(D + 1);
  }

  rep(i, DAY) {
    const int day = i + 1;
    const int type_idx = type[i] - 1;

    ret.held_days[type_idx].insert(day);
    ret.type[i] = type_idx;
    ret.score += s[i][type_idx];

    last[type_idx] = day;

    rep(j, CONTEST_TYPE) { ret.score -= c[j] * max(day - last[j], 0); }
  }

  return ret;
}

state modity(const state &cur, int day, int query) {
  const int day_idx = day - 1;
  const int q_idx = query - 1;
  state ret = cur;

  {
    const int cur_type = ret.type[day_idx];

    const auto it = ret.held_days[cur_type].lower_bound(day);
    const auto before_it = prev(it);
    const auto after_it = next(it);

    ret.score -= c[cur_type] * (*it - *before_it) * (*after_it - *it);
    ret.score -= s[day_idx][cur_type];
    ret.type[day_idx] = -1;
    ret.held_days[cur_type].erase(it);
  }

  {
    const int next_type = q_idx;
    ret.type[day_idx] = next_type;
    ret.held_days[next_type].insert(day);

    const auto it = ret.held_days[next_type].lower_bound(day);
    const auto before_it = prev(it);
    const auto after_it = next(it);

    ret.score += c[next_type] * (*it - *before_it) * (*after_it - *it);
    ret.score += s[day_idx][next_type];
  }

  return ret;
}

state swap_type(const state &cur, int type_a, int type_b) {
  const int type_a_idx = type_a - 1;
  const int type_b_idx = type_b - 1;

  state ret = cur;

  for (auto &type_idx : {type_a_idx, type_b_idx}) {
    int prev_day = 0;
    const int alt_type_idx = type_a_idx ^ type_b_idx ^ type_idx;
    for (auto &day : ret.held_days[type_idx]) {
      const int day_idx = day - 1;
      if (0 <= day_idx and day_idx < D) {
        ret.score += (s[day_idx][alt_type_idx] - s[day_idx][type_idx]);
      }

      const int duration = day - prev_day;
      ret.score +=
          (c[alt_type_idx] - c[type_idx]) * (duration * (duration - 1) / 2);
      prev_day = day;
    }
  }

  swap(ret.held_days[type_a_idx], ret.held_days[type_b_idx]);
  return ret;
}

state swap_days(const state &cur, int day_a, int day_b) {
  const int day_a_idx = day_a - 1;
  const int day_b_idx = day_b - 1;

  const int type_a = cur.type[day_a_idx] + 1;
  const int type_b = cur.type[day_b_idx] + 1;

  const state tmp = modity(cur, day_a, type_b);
  const state ret = modity(tmp, day_b, type_a);

  return ret;
}

state greedy_solution() {
  vector<int> type(D, 1);

  vector<int> last(CONTEST_TYPE, 0);
  int score = 0;

  rep(i, D) {
    const int day = i + 1;
    rep(j, CONTEST_TYPE) { score -= c[j] * max(day - last[j], 0); }

    int cmax = score;

    rep(j, CONTEST_TYPE) {
      int nscore = score;
      nscore += s[i][j];
      nscore += c[j] * max(day - last[j], 0);
      if (chmax(cmax, nscore)) {
        type[i] = j + 1;
      }
    }

    score = cmax;
    last[type[i] - 1] = day;
  }

  return calc_init(type);
}

void output(const state &cur) {
  rep(i, D) { cout << cur.type[i] + 1 << endl; }
}

int main(void) {
  input();
  const state greedy_init = greedy_solution();
  output(greedy_init);
  return 0;
}

Error: -6
double free or corruption (out)


Fixed submission:

#include <bits/stdc++.h>
#include <sys/types.h>
#include <unistd.h>

#define _overload(_1, _2, _3, name, ...) name
#define _rep(i, n) _range(i, 0, n)
#define _range(i, a, b) for (int i = int(a); i < int(b); ++i)
#define rep(...) _overload(__VA_ARGS__, _range, _rep, )(__VA_ARGS__)

#define _rrep(i, n) _rrange(i, n, 0)
#define _rrange(i, a, b) for (int i = int(a) - 1; i >= int(b); --i)
#define rrep(...) _overload(__VA_ARGS__, _rrange, _rrep, )(__VA_ARGS__)

#define _all(arg) begin(arg), end(arg)
#define uniq(arg) sort(_all(arg)), (arg).erase(unique(_all(arg)), end(arg))
#define getidx(ary, key) lower_bound(_all(ary), key) - begin(ary)
#define clr(a, b) memset((a), (b), sizeof(a))
#define bit(n) (1LL << (n))
#define popcount(n) (__builtin_popcountll(n))

using namespace std;

template <class T> bool chmax(T &a, const T &b) {
  return (a < b) ? (a = b, 1) : 0;
}
template <class T> bool chmin(T &a, const T &b) {
  return (b < a) ? (a = b, 1) : 0;
}

using ll = long long;
using R = long double;
const R EPS = 1e-9L; // [-1000,1000]->EPS=1e-8 [-10000,10000]->EPS=1e-7
inline int sgn(const R &r) { return (r > EPS) - (r < -EPS); }
inline R sq(R x) { return sqrt(max(x, 0.0L)); }

template <typename T> vector<T> make_vector(size_t sz) { return vector<T>(sz); }

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

template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value != 0>::type fill_value(U &u,
                                                               const V... v) {
  u = U(v...);
}

template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value == 0>::type fill_value(U &u,
                                                               const V... v) {
  for (auto &e : u) {
    fill_value<T>(e, v...);
  }
}

const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};

const pid_t pid = getpid();
// Problem Specific Parameter:

const int CONTEST_TYPE = 26;
int D;
int c[CONTEST_TYPE], s[365][CONTEST_TYPE];

void input() {
  cin >> D;

  rep(i, CONTEST_TYPE) { cin >> c[i]; }

  rep(i, D) rep(j, CONTEST_TYPE) { cin >> s[i][j]; }
}

int score(const vector<int> &type) {
  vector<int> last(CONTEST_TYPE, 0);

  int ret = 0;
  rep(i, D) {
    const int day = i + 1;
    const int type_idx = type[i] - 1;

    ret += s[i][type_idx];
    last[type_idx] = day;

    rep(j, CONTEST_TYPE) { ret -= c[j] * max(day - last[j], 0); }
  }

  return ret;
}

int main(void) {
  input();
  vector<int> t(D);
  rep(i, D) cin >> t[i];
  cout << score(t) << endl;
  return 0;
}