Problem p02972 (C++)

Buggy submission (status: Runtime Error):
#include <algorithm> //sort()
#include <iostream>
#include <numeric>
#include <stdlib.h>
#include <tuple>
#include <vector> //vector

#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define debug(a) cout << "debug (" #a "):" << endl << (a) << endl;

typedef uint64_t ulint;
typedef int64_t lint;

using namespace std;

template <class T> inline bool chmin(T &a, T b);
template <class T> inline bool chmax(T &a, T b);
template <typename T> ostream &operator<<(ostream &s, const vector<T> &v);

template <class T> lint sum(vector<T> a);
template <class T> double ave(vector<T> a);

lint n, k;
lint h, w;

int main() {
  //////////////////////////////////////////////////////

  cin >> n;
  vector<lint> a(n);
  // fpair<lint,lint> p = make_pair(1,2);
  // tuple<lint,lint,lint> t  = make_tuple(1,2,3);

  rep(i, n) { cin >> a[i]; }

  // 入力自動生成始まり

  // n = 10000;
  // vector<lint> a(n,1);

  // 入力自動生成終わり

  // debug(i);
  vector<char> ball(n, 0); // 入れた位置をtrueに
  lint ballnum = 0;

  // debug(9991);

  for (lint k = n; k >= 1; k--) {
    // debug(k);
    lint sumb = 0;
    // 倍数の探索
    for (lint j = k; j <= n; j += k) {
      sumb += ball[j];
    }
    // debug(a[k-1]);
    // debug(sumb);
    // debug((sumb + a[k-1])%2);

    // if(k == 5000)
    // {
    //     debug(sumb);
    //     debug(a[k-1]);
    // }

    ball[k] = (sumb + a[k - 1]) % 2; // 入れたり入れなかったり
    ballnum += ball[k];
  }

  // debug(9992);

  cout << ballnum << endl;

  rep(i, n) {
    if (ball[i + 1] == 1)
      cout << i + 1 << " ";
  }
  if (ballnum > 0)
    cout << endl;

  // debug(ball);

  // 昇順ソート
  // sort(all(a));

  // sort(input.begin() , input.end());

  // uint64_t max = numeric_limits<uint64_t>::max();

  //////////////////////////////////////////////////////
  // DP

  //     // 無限大の値
  //     const uint64_t INF = (uint64_t)1 << 60;
  //     //const int64_t NINF = -1 * ((int64_t)1 << 60 );

  //     // DP テーブル
  //     uint64_t dp[100010];

  //     //DPテーブル初期化（最小化用）
  //     for (int i = 0; i < 100010; ++i)
  //     {
  //         //dp[i] = INF;
  //         dp[i] = 0;
  //     }

  //     // 初期条件
  //     dp[0] = 0;

  //     // ループ
  //     for (int i = 1; i <= n; ++i) {
  //         //chmin( dp[i], dp[i - 1] + abs( input[i] - input[i - 1] ));
  //         //if (i < 2)continue;
  //         //chmin( dp[i], dp[i - 2] + abs( input[i] - input[i - 2] ));

  //         // chmax ( dp [i] , dp[i - 1]);
  //         // chmax ( dp [i] , dp[i - 1] + input[i]);
  //         // cout << "dp[" << i <<"] = " << dp[i] << endl;

  //     }

  // //////////////////////////////////////////////////////

  //     cout << dp[n] << endl;

  //////////////////////////////////////////////////////
  // Ctrl + Opt + N to make
  return 0;
}

// 最小化用関数
template <class T> inline bool chmin(T &a, T b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}

// 最大化関数
template <class T> inline bool chmax(T &a, T b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}

// vectorprint用
template <typename T> ostream &operator<<(ostream &s, const vector<T> &v) {
  int len = v.size();
  for (int i = 0; i < len; ++i) {
    s << v[i];
    if (i < len - 1)
      s << "\t";
  }
  return s;
}

// //合計
// template<class T> lint sum(vector<T> a)
// {
//     return std::accumulate(a.begin(), a.end(), 0);
// }

// //平均
// template<class T> double ave(vector<T> a)
// {
//     return std::accumulate(a.begin(), a.end(), 0.0) / a.size();
// }


Fixed submission:
#include <algorithm> //sort()
#include <iostream>
#include <numeric>
#include <stdlib.h>
#include <tuple>
#include <vector> //vector

#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define debug(a) cout << "debug (" #a "):" << endl << (a) << endl;

typedef uint64_t ulint;
typedef int64_t lint;

using namespace std;

template <class T> inline bool chmin(T &a, T b);
template <class T> inline bool chmax(T &a, T b);
template <typename T> ostream &operator<<(ostream &s, const vector<T> &v);

template <class T> lint sum(vector<T> a);
template <class T> double ave(vector<T> a);

lint n, k;
lint h, w;

int main() {
  //////////////////////////////////////////////////////

  cin >> n;
  vector<lint> a(n);
  // fpair<lint,lint> p = make_pair(1,2);
  // tuple<lint,lint,lint> t  = make_tuple(1,2,3);

  rep(i, n) { cin >> a[i]; }

  // 入力自動生成始まり

  // n = 10000;
  // vector<lint> a(n,1);

  // 入力自動生成終わり

  // debug(i);
  vector<char> ball(n + 1, 0); // 入れた位置をtrueに
  lint ballnum = 0;

  // debug(9991);

  for (lint k = n; k >= 1; k--) {
    // debug(k);
    lint sumb = 0;
    // 倍数の探索
    for (lint j = k; j <= n; j += k) {
      sumb += ball[j];
    }
    // debug(a[k-1]);
    // debug(sumb);
    // debug((sumb + a[k-1])%2);

    // if(k == 5000)
    // {
    //     debug(sumb);
    //     debug(a[k-1]);
    // }

    ball[k] = (sumb + a[k - 1]) % 2; // 入れたり入れなかったり
    ballnum += ball[k];
  }

  // debug(9992);

  cout << ballnum << endl;

  rep(i, n) {
    if (ball[i + 1] == 1)
      cout << i + 1 << " ";
  }
  if (ballnum > 0)
    cout << endl;

  // debug(ball);

  // 昇順ソート
  // sort(all(a));

  // sort(input.begin() , input.end());

  // uint64_t max = numeric_limits<uint64_t>::max();

  //////////////////////////////////////////////////////
  // DP

  //     // 無限大の値
  //     const uint64_t INF = (uint64_t)1 << 60;
  //     //const int64_t NINF = -1 * ((int64_t)1 << 60 );

  //     // DP テーブル
  //     uint64_t dp[100010];

  //     //DPテーブル初期化（最小化用）
  //     for (int i = 0; i < 100010; ++i)
  //     {
  //         //dp[i] = INF;
  //         dp[i] = 0;
  //     }

  //     // 初期条件
  //     dp[0] = 0;

  //     // ループ
  //     for (int i = 1; i <= n; ++i) {
  //         //chmin( dp[i], dp[i - 1] + abs( input[i] - input[i - 1] ));
  //         //if (i < 2)continue;
  //         //chmin( dp[i], dp[i - 2] + abs( input[i] - input[i - 2] ));

  //         // chmax ( dp [i] , dp[i - 1]);
  //         // chmax ( dp [i] , dp[i - 1] + input[i]);
  //         // cout << "dp[" << i <<"] = " << dp[i] << endl;

  //     }

  // //////////////////////////////////////////////////////

  //     cout << dp[n] << endl;

  //////////////////////////////////////////////////////
  // Ctrl + Opt + N to make
  return 0;
}

// 最小化用関数
template <class T> inline bool chmin(T &a, T b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}

// 最大化関数
template <class T> inline bool chmax(T &a, T b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}

// vectorprint用
template <typename T> ostream &operator<<(ostream &s, const vector<T> &v) {
  int len = v.size();
  for (int i = 0; i < len; ++i) {
    s << v[i];
    if (i < len - 1)
      s << "\t";
  }
  return s;
}

// //合計
// template<class T> lint sum(vector<T> a)
// {
//     return std::accumulate(a.begin(), a.end(), 0);
// }

// //平均
// template<class T> double ave(vector<T> a)
// {
//     return std::accumulate(a.begin(), a.end(), 0.0) / a.size();
// }