Problem p02964 (C++)

Buggy submission (status: Runtime Error):
#include <algorithm>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

#define FOR(i, k, n) for (int(i) = (k); (i) < (n); ++(i))
#define rep(i, n) FOR(i, 0, n)
#define all(v) begin(v), end(v)
#define debug(x)     // std::cerr<<#x<<": "<<x<<"\n"
#define debug2(x, y) // std::cerr<<#x<<": "<<x<<", "<<#y<<": "<<y<<"\n"
#define debug3(                                                                \
    x, y,                                                                      \
    z) // std::cerr<<#x<<": "<<x<<", "<<#y<<": "<<y<<", "<<#z<<": "<<z<<"\n"

using ll = long long;
using vi = std::vector<int>;
using vvi = std::vector<vi>;
using vll = std::vector<ll>;
using vvll = std::vector<vll>;
template <typename T> using vvec = std::vector<std::vector<T>>;
template <typename T> auto make_v(size_t sz) { return std::vector<T>(sz); }
template <typename T, typename... Ts> auto make_v(size_t sz, Ts... ts) {
  return std::vector<decltype(make_v<T>(ts...))>(sz, make_v<T>(ts...));
}
template <typename T> void fill_v(T &var, const T &x) { var = x; }
template <typename V, typename T> void fill_v(V &v, const T &x) {
  for (auto &&w : v) {
    fill_v(w, x);
  }
}

template <typename T>
std::ostream &operator<<(std::ostream &s, const std::vector<T> &v) {
  int sz = v.size();
  s << "\n";
  rep(i, sz) {
    s << v[i];
    if (i < sz - 1) {
      s << "\t";
    }
  }
  s << "\n";
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s,
                         const std::vector<std::vector<T>> &v) {
  for (auto &&w : v) {
    s << w;
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::deque<T> &v) {
  int sz = v.size();
  s << "\n";
  rep(i, sz) {
    s << v[i];
    if (i < sz - 1) {
      s << "\t";
    }
  }
  s << "\n";
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::deque<std::deque<T>> &v) {
  for (auto &&w : v) {
    s << w;
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::set<T> &v) {
  s << "\n";
  for (auto &&elm : v) {
    s << elm << "\t";
  }
  s << "\n";
  return s;
}

inline void scan(int &a) { scanf("%d", &a); }
inline void scan(ll &a) { scanf("%lld", &a); }
inline void scan(char &a) { scanf(" %c", &a); }
inline void scan(double &a) { scanf("%lf", &a); }
inline void scan(std::string &s) {
  char BUF[3000000];
  scanf(" %s", BUF);
  s = std::string(BUF);
}
template <typename T> inline void scan(std::vector<T> &v) {
  for (auto &&sv : v) {
    scan(sv);
  }
}
template <typename First, typename... Args>
inline void scan(First &f, Args &...args) {
  scan(f);
  scan(args...);
}
inline void print(int a) { printf("%d\n", a); }
inline void print(ll a) { printf("%lld\n", a); }
inline void print(double a) { printf("%.12f\n", a); }
inline void print(std::string s) { std::cout << s << "\n"; }

using namespace std;

struct Monoid {
  using T = int; // type or class of monoid
  static T operate(const T &left, const T &right) {
    if (left != -1)
      return left;
    else
      return right;
  }
  static constexpr T identity() { return T(-1); } // 単位元
};

struct M_act {
  using T = int;
  using OperatorMonoid = Monoid;
  static T act(const OperatorMonoid::T &m, const T &a) {
    if (m != -1)
      return m;
    else
      return a;
  }
};

template <class M_act> class SegTree {
private:
  using T = typename M_act::T;
  using OM = typename M_act::OperatorMonoid;
  using M = typename OM::T;
  const int n, h;
  std::vector<T> uv; // underlying values
  std::vector<M> deferred_action;

  void propagate(const M &m, int i) {
    if (i < n)
      deferred_action[i] =
          OM::operate(m, deferred_action[i]); // if not leaves, unite actions
    else {
      i -= n;
      uv[i] = M_act::act(m, uv[i]); // if leaves, act immediately
    }
  }

  void propagate_from(int i) {
    if (deferred_action[i] == OM::identity()) {
      return;
    }
    propagate(deferred_action[i], i << 1);
    propagate(deferred_action[i], i << 1 | 1);
    deferred_action[i] = OM::identity();
  }

  void propagate_to_uv(int i) {
    i += n;
    for (int j = h; j > 0; --j)
      propagate_from(i >> j);
  }

  int lg(int n_) {
    n_ -= 1;
    int h_ = 0;
    while (n_ >> h_)
      ++h_;
    return h_;
  }

public:
  SegTree(int n_, const T &x)
      : n(n_), h(lg(n)), uv(n, x), deferred_action(n, OM::identity()) {}
  SegTree(const std::vector<T> &v)
      : n(v.size()), h(lg(n)), uv(v), deferred_action(n, OM::identity()) {}
  template <class Itr>
  SegTree(Itr first, Itr last)
      : n(std::distance(first, last)), h(lg(n)), uv(first, last),
        deferred_action(n, OM::identity()) {}

  void act(int l, int r, const M &m) {
    propagate_to_uv(l);
    propagate_to_uv(r - 1);
    l += n, r += n;
    for (; l < r; l >>= 1, r >>= 1) {
      if (l & 1)
        propagate(m, l++);
      if (r & 1)
        propagate(m, r - 1);
    }
  }

  void propagate_all() {
    for (int i = 1; i < n; ++i)
      propagate_from(i);
  }

  void set(int i, const T &x) {
    propagate_to_uv(i);
    uv[i] = x;
  }

  T get(int i) {
    T ret = uv[i];
    i += n;
    while (i >>= 1)
      ret = M_act::act(deferred_action[i], ret);
    return ret;
  }

  std::vector<T> get_v() { return uv; }
};

int main() {
  int n;
  ll k;
  scan(n, k);
  vi a(n);
  scan(a);
  int m = 200001;
  m = 10;
  vvi indices(m);
  rep(i, n) { indices[a[i]].push_back(i); }
  debug(indices);

  vi remain(n + 1, n);
  {
    vi wolfi;
    vi lefti;
    set<int> si;
    for (int i = n - 1; i >= 0; --i) {
      if (si.find(a[i]) == end(si)) {
        wolfi.push_back(i);
        si.insert(a[i]);
      }
    }
    reverse(all(wolfi));
    debug(wolfi);
    for (int ind : wolfi) {
      int lb = lower_bound(all(indices[a[ind]]), ind) - begin(indices[a[ind]]);
      if (lb == 0) {
        lefti.push_back(0);
      } else {
        lefti.push_back(indices[a[ind]][lb - 1] + 1);
      }
    }
    debug(lefti);

    int sz = wolfi.size();
    auto segt = SegTree<M_act>(n, n);
    for (int i = sz - 1; i >= 0; --i) {
      remain[wolfi[i]] = wolfi[i];
    }
    debug(remain);
    for (int i = n - 1; i >= 0; --i) {
      if (remain[i] != n) {
        continue;
      }
      auto ub = upper_bound(all(indices[a[i]]), i);
      assert(ub != end(indices[a[i]]));
      remain[i] = remain[(*ub) + 1];
    }
    debug(remain);
  }

  vi first_index(m, -1);
  rep(i, n) {
    if (first_index[a[i]] == -1) {
      first_index[a[i]] = i;
    }
  }
  debug(first_index);

  int t;
  int prev = -1; // first index remaining
  vi prevs;
  for (int i = 1; true; ++i) {
    t = i;
    if (prev == -1) {
      prev = remain[0];
    } else {
      int fi = first_index[a[prev]];
      prev = remain[fi + 1];
    }
    prevs.push_back(prev);
    debug(prev);
    if (prev == n) {
      break;
    }
  }
  debug(t);

  int target = k % t;
  if (target == 0) {
    return 0;
  }

  int start_index;
  if (target == 1) {
    start_index = 0;
  } else {
    int prev = prevs[target - 2];
    start_index = first_index[a[prev]] + 1;
  }
  vi ans;
  for (int i = start_index;;) {
    if (remain[i] == n) {
      break;
    }
    ans.push_back(remain[i]);
    i = remain[i] + 1;
  }
  debug(ans);
  int sz = ans.size();
  rep(i, sz) { printf("%d%c", a[ans[i]], " \n"[i == sz - 1]); }

  return 0;
}


Fixed submission:
#include <algorithm>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

#define FOR(i, k, n) for (int(i) = (k); (i) < (n); ++(i))
#define rep(i, n) FOR(i, 0, n)
#define all(v) begin(v), end(v)
#define debug(x)     // std::cerr<<#x<<": "<<x<<"\n"
#define debug2(x, y) // std::cerr<<#x<<": "<<x<<", "<<#y<<": "<<y<<"\n"
#define debug3(                                                                \
    x, y,                                                                      \
    z) // std::cerr<<#x<<": "<<x<<", "<<#y<<": "<<y<<", "<<#z<<": "<<z<<"\n"

using ll = long long;
using vi = std::vector<int>;
using vvi = std::vector<vi>;
using vll = std::vector<ll>;
using vvll = std::vector<vll>;
template <typename T> using vvec = std::vector<std::vector<T>>;
template <typename T> auto make_v(size_t sz) { return std::vector<T>(sz); }
template <typename T, typename... Ts> auto make_v(size_t sz, Ts... ts) {
  return std::vector<decltype(make_v<T>(ts...))>(sz, make_v<T>(ts...));
}
template <typename T> void fill_v(T &var, const T &x) { var = x; }
template <typename V, typename T> void fill_v(V &v, const T &x) {
  for (auto &&w : v) {
    fill_v(w, x);
  }
}

template <typename T>
std::ostream &operator<<(std::ostream &s, const std::vector<T> &v) {
  int sz = v.size();
  s << "\n";
  rep(i, sz) {
    s << v[i];
    if (i < sz - 1) {
      s << "\t";
    }
  }
  s << "\n";
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s,
                         const std::vector<std::vector<T>> &v) {
  for (auto &&w : v) {
    s << w;
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::deque<T> &v) {
  int sz = v.size();
  s << "\n";
  rep(i, sz) {
    s << v[i];
    if (i < sz - 1) {
      s << "\t";
    }
  }
  s << "\n";
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::deque<std::deque<T>> &v) {
  for (auto &&w : v) {
    s << w;
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::set<T> &v) {
  s << "\n";
  for (auto &&elm : v) {
    s << elm << "\t";
  }
  s << "\n";
  return s;
}

inline void scan(int &a) { scanf("%d", &a); }
inline void scan(ll &a) { scanf("%lld", &a); }
inline void scan(char &a) { scanf(" %c", &a); }
inline void scan(double &a) { scanf("%lf", &a); }
inline void scan(std::string &s) {
  char BUF[3000000];
  scanf(" %s", BUF);
  s = std::string(BUF);
}
template <typename T> inline void scan(std::vector<T> &v) {
  for (auto &&sv : v) {
    scan(sv);
  }
}
template <typename First, typename... Args>
inline void scan(First &f, Args &...args) {
  scan(f);
  scan(args...);
}
inline void print(int a) { printf("%d\n", a); }
inline void print(ll a) { printf("%lld\n", a); }
inline void print(double a) { printf("%.12f\n", a); }
inline void print(std::string s) { std::cout << s << "\n"; }

using namespace std;

struct Monoid {
  using T = int; // type or class of monoid
  static T operate(const T &left, const T &right) {
    if (left != -1)
      return left;
    else
      return right;
  }
  static constexpr T identity() { return T(-1); } // 単位元
};

struct M_act {
  using T = int;
  using OperatorMonoid = Monoid;
  static T act(const OperatorMonoid::T &m, const T &a) {
    if (m != -1)
      return m;
    else
      return a;
  }
};

template <class M_act> class SegTree {
private:
  using T = typename M_act::T;
  using OM = typename M_act::OperatorMonoid;
  using M = typename OM::T;
  const int n, h;
  std::vector<T> uv; // underlying values
  std::vector<M> deferred_action;

  void propagate(const M &m, int i) {
    if (i < n)
      deferred_action[i] =
          OM::operate(m, deferred_action[i]); // if not leaves, unite actions
    else {
      i -= n;
      uv[i] = M_act::act(m, uv[i]); // if leaves, act immediately
    }
  }

  void propagate_from(int i) {
    if (deferred_action[i] == OM::identity()) {
      return;
    }
    propagate(deferred_action[i], i << 1);
    propagate(deferred_action[i], i << 1 | 1);
    deferred_action[i] = OM::identity();
  }

  void propagate_to_uv(int i) {
    i += n;
    for (int j = h; j > 0; --j)
      propagate_from(i >> j);
  }

  int lg(int n_) {
    n_ -= 1;
    int h_ = 0;
    while (n_ >> h_)
      ++h_;
    return h_;
  }

public:
  SegTree(int n_, const T &x)
      : n(n_), h(lg(n)), uv(n, x), deferred_action(n, OM::identity()) {}
  SegTree(const std::vector<T> &v)
      : n(v.size()), h(lg(n)), uv(v), deferred_action(n, OM::identity()) {}
  template <class Itr>
  SegTree(Itr first, Itr last)
      : n(std::distance(first, last)), h(lg(n)), uv(first, last),
        deferred_action(n, OM::identity()) {}

  void act(int l, int r, const M &m) {
    propagate_to_uv(l);
    propagate_to_uv(r - 1);
    l += n, r += n;
    for (; l < r; l >>= 1, r >>= 1) {
      if (l & 1)
        propagate(m, l++);
      if (r & 1)
        propagate(m, r - 1);
    }
  }

  void propagate_all() {
    for (int i = 1; i < n; ++i)
      propagate_from(i);
  }

  void set(int i, const T &x) {
    propagate_to_uv(i);
    uv[i] = x;
  }

  T get(int i) {
    T ret = uv[i];
    i += n;
    while (i >>= 1)
      ret = M_act::act(deferred_action[i], ret);
    return ret;
  }

  std::vector<T> get_v() { return uv; }
};

int main() {
  int n;
  ll k;
  scan(n, k);
  vi a(n);
  scan(a);
  int m = 200001;
  // m = 10;
  vvi indices(m);
  rep(i, n) { indices[a[i]].push_back(i); }
  debug(indices);

  vi remain(n + 1, n);
  {
    vi wolfi;
    vi lefti;
    set<int> si;
    for (int i = n - 1; i >= 0; --i) {
      if (si.find(a[i]) == end(si)) {
        wolfi.push_back(i);
        si.insert(a[i]);
      }
    }
    reverse(all(wolfi));
    debug(wolfi);
    for (int ind : wolfi) {
      int lb = lower_bound(all(indices[a[ind]]), ind) - begin(indices[a[ind]]);
      if (lb == 0) {
        lefti.push_back(0);
      } else {
        lefti.push_back(indices[a[ind]][lb - 1] + 1);
      }
    }
    debug(lefti);

    int sz = wolfi.size();
    auto segt = SegTree<M_act>(n, n);
    for (int i = sz - 1; i >= 0; --i) {
      remain[wolfi[i]] = wolfi[i];
    }
    debug(remain);
    for (int i = n - 1; i >= 0; --i) {
      if (remain[i] != n) {
        continue;
      }
      auto ub = upper_bound(all(indices[a[i]]), i);
      assert(ub != end(indices[a[i]]));
      remain[i] = remain[(*ub) + 1];
    }
    debug(remain);
  }

  vi first_index(m, -1);
  rep(i, n) {
    if (first_index[a[i]] == -1) {
      first_index[a[i]] = i;
    }
  }
  debug(first_index);

  int t;
  int prev = -1; // first index remaining
  vi prevs;
  for (int i = 1; true; ++i) {
    t = i;
    if (prev == -1) {
      prev = remain[0];
    } else {
      int fi = first_index[a[prev]];
      prev = remain[fi + 1];
    }
    prevs.push_back(prev);
    debug(prev);
    if (prev == n) {
      break;
    }
  }
  debug(t);

  int target = k % t;
  if (target == 0) {
    return 0;
  }

  int start_index;
  if (target == 1) {
    start_index = 0;
  } else {
    int prev = prevs[target - 2];
    start_index = first_index[a[prev]] + 1;
  }
  vi ans;
  for (int i = start_index;;) {
    if (remain[i] == n) {
      break;
    }
    ans.push_back(remain[i]);
    i = remain[i] + 1;
  }
  debug(ans);
  int sz = ans.size();
  rep(i, sz) { printf("%d%c", a[ans[i]], " \n"[i == sz - 1]); }

  return 0;
}