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

#include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <numeric>
#include <queue>
#include <string>
#include <utility>
#include <vector>

using namespace std;
#define ALL(a) (a).begin(), (a).end()
#define REP(i, n) for (size_t i = 0; i < (n); i++)
#define nvec(T, v, n)                                                          \\
  vector<T> v(n);                                                              \\
  REP(i, n) { cin >> (v)[i]; }
#define npairs(T1, T2, v, n)                                                   \\
  vector<pair<T1, T2>> v(n);                                                   \\
  REP(i, n) { cin >> v[i].first >> v[i].second; }
#define ntuples(T1, T2, T3, v, n)                                              \\
  vector<tuple<T1, T2, T3>> v(n);                                              \\
  REP(i, n) { cin >> get<0>(v[i]) >> get<1>(v[i]) >> get<2>(v[i]); }
#define vec2d(T, v, m, n) vector<vector<T>>(v)(m, vector<T>(n))
#define nvec2d(T, v, m, n)                                                     \\
  vec2d(T, v, m, n);                                                           \\
  REP(j, m) {                                                                  \\
    REP(i, n) { cin >> (v[j])[i]; }                                            \\
  }

#define min_index(v) size_t(min_element(all(v)) - (v).begin())
#define max_index(v) size_t(max_element(all(v)) - (v).begin())
#define min_e(v) *min_element(ALL(v))
#define max_e(v) *max_element(ALL(v))

#define count_le(v, a) size_t(upper_bound(ALL(v), a) - (v).begin())
#define count_lt(v, a) size_t(lower_bound(ALL(v), a) - (v).begin())
#define count_ge(v, a) size_t((v).end() - lower_bound(ALL(v), a))
#define count_gt(v, a) size_t((v).end() - upper_bound(ALL(v), a))

#define order(neq_sl) [](const auto s, const auto l) { return neq_sl; }
#define make_lr(v, type, l, r)                                                 \\
  vector<type> l(n + 1), r(n + 1);                                             \\
  FOR(i, n) {                                                                  \\
    l[i + 1] = l[i] + v[i];                                                    \\
    r[i + 1] = r[i] + v[n - 1 - i];                                            \\
  }

#define acm accumulate
#define SUM(v) accumulate(ALL(v), 0l)
#define SORT(v) sort(ALL(v))

#define GCD(v) gcd(ALL(v), 0l)

/*template <typename T>
T gcd(T a, T b) {
    if (a > b) swap(a, b);
    if (a == 0) return b;
    return gcd(b%a, a);
}
template <typename InputItr, typename T>
T gcd(InputItr first, InputItr last, T init) {
    for (; first != last; ++first) init = gcd(init, *first);
    return init;
}*/

template <typename T> using vec = vector<T>;

template <typename T> using vvec = vector<vector<T>>;

class cycle {
public:
  cycle() {
    score = 0;
    len = 0;
    elems = {};
  }
  long score;
  int len;
  vector<int> elems;
};

int main() {
  int n, k;
  cin >> n >> k;
  nvec(int, p, n);
  nvec(int, c, n);
  for (int i = 0; i < n; i++) {
    p[i]--;
  }
  vvec<long> score(n, vector<long>(1, 0));

  vec<cycle> cycles;
  vec<int> isCycle(n, -1);
  int cyclenum = 0;

  for (int i = 0; i < n; i++) {
    if (isCycle[i] == -1) {
      cycle cc;
      int e = i;
      do {
        cc.elems.push_back(e);
        cc.len++;
        isCycle[e] = cyclenum;
        e = p[e];
        score[i].push_back(cc.score += c[e]);
      } while (e != i);
      cycles.push_back(cc);
      cyclenum++;
    } else {
      for (int e = p[i];; e = p[e]) {
        score[i].push_back(c[e] + score[i].back());
        if (e == i)
          break;
      }
    }
  }

  long ans = -100000000000;

  for (cycle cc : cycles) {
    long s = cc.score * (k / cc.len);
    int m = k % cc.len;
    for (int e : cc.elems) {
      if (s > 0) {
        for (int i = 0; i <= m; i++) {
          ans = max(ans, s + score[e][i]);
        }
        for (int i = 0; i < cc.len - m; i++) {
          ans = max(ans, s - score[e][i]);
        }
      } else {

        for (int i = 1; i <= min(k, cc.len); i++) {
          ans = max(ans, score[e][i]);
        }
      }
    }
  }
  cout << ans;
}

Error: -6
malloc(): corrupted top size


Fixed submission:

#include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <numeric>
#include <queue>
#include <string>
#include <utility>
#include <vector>

using namespace std;
#define ALL(a) (a).begin(), (a).end()
#define REP(i, n) for (size_t i = 0; i < (n); i++)
#define nvec(T, v, n)                                                          \\
  vector<T> v(n);                                                              \\
  REP(i, n) { cin >> (v)[i]; }
#define npairs(T1, T2, v, n)                                                   \\
  vector<pair<T1, T2>> v(n);                                                   \\
  REP(i, n) { cin >> v[i].first >> v[i].second; }
#define ntuples(T1, T2, T3, v, n)                                              \\
  vector<tuple<T1, T2, T3>> v(n);                                              \\
  REP(i, n) { cin >> get<0>(v[i]) >> get<1>(v[i]) >> get<2>(v[i]); }
#define vec2d(T, v, m, n) vector<vector<T>>(v)(m, vector<T>(n))
#define nvec2d(T, v, m, n)                                                     \\
  vec2d(T, v, m, n);                                                           \\
  REP(j, m) {                                                                  \\
    REP(i, n) { cin >> (v[j])[i]; }                                            \\
  }

#define min_index(v) size_t(min_element(all(v)) - (v).begin())
#define max_index(v) size_t(max_element(all(v)) - (v).begin())
#define min_e(v) *min_element(ALL(v))
#define max_e(v) *max_element(ALL(v))

#define count_le(v, a) size_t(upper_bound(ALL(v), a) - (v).begin())
#define count_lt(v, a) size_t(lower_bound(ALL(v), a) - (v).begin())
#define count_ge(v, a) size_t((v).end() - lower_bound(ALL(v), a))
#define count_gt(v, a) size_t((v).end() - upper_bound(ALL(v), a))

#define order(neq_sl) [](const auto s, const auto l) { return neq_sl; }
#define make_lr(v, type, l, r)                                                 \\
  vector<type> l(n + 1), r(n + 1);                                             \\
  FOR(i, n) {                                                                  \\
    l[i + 1] = l[i] + v[i];                                                    \\
    r[i + 1] = r[i] + v[n - 1 - i];                                            \\
  }

#define acm accumulate
#define SUM(v) accumulate(ALL(v), 0l)
#define SORT(v) sort(ALL(v))

#define GCD(v) gcd(ALL(v), 0l)

/*template <typename T>
T gcd(T a, T b) {
    if (a > b) swap(a, b);
    if (a == 0) return b;
    return gcd(b%a, a);
}
template <typename InputItr, typename T>
T gcd(InputItr first, InputItr last, T init) {
    for (; first != last; ++first) init = gcd(init, *first);
    return init;
}*/

template <typename T> using vec = vector<T>;

template <typename T> using vvec = vector<vector<T>>;

class cycle {
public:
  cycle() {
    score = 0;
    len = 0;
    elems = {};
  }
  long score;
  int len;
  vector<int> elems;
};

int main() {
  int n, k;
  cin >> n >> k;
  nvec(int, p, n);
  nvec(int, c, n);
  for (int i = 0; i < n; i++) {
    p[i]--;
  }
  vvec<int> place(n, vector<int>(1));
  vvec<long> point(n, vector<long>(1));

  for (int i = 0; i < n; i++) {
    place[i][0] = i;
    point[i][0] = 0;
  }
  for (int j = 1; j < n; j++) {
    for (int i = 0; i < n; i++) {
      place[i][j] = p[place[i][j - 1]];
      point[i][j] = c[place[i][j]] + point[i][j - 1];
    }
  }
  if (k < 5000) {
    long ans = 0;
    for (int i = 0; i < n; i++) {
      ans = max(ans, point[i][k]);
    }
    cout << ans;
    return 0;
  }
  while (true) {
    string s;
    s = "にゃーん";
  }
  /*for (int i = 0; i < n; i++) {
    while(find(ALL(v[i]),v[i].back())==v[i].end()-1){
      v[i].push_back(p[v[i].back()]-1);
    }
    cycle nyan;
    for (auto itr = find(ALL(v[i]),v[i].back()); itr < v[i].end()-1; itr++) {
      nyan.elems.push_back(*itr);
      nyan.score += c[*itr];
    }
    nyan.len = nyan.elems.size();

  }
  */
}

/* きょむ〜 */