Problem p02891 (C++)

Buggy submission (status: Time Limit Exceeded):
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#ifdef DEBUG
#include "./Lib/debug.hpp"
#else
#define dump(...)
template <class T> inline auto d_val(T a, T b) { return a; }
#endif

/* (=＾o＾=) */
#define int ll

/* macro */
#define FOR(i, b, e) for (ll i = (ll)(b); i < (ll)(e); ++i)
#define RFOR(i, b, e) for (ll i = (ll)(e - 1); i >= (ll)(b); --i)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#define REPC(x, c) for (const auto &x : (c))
#define REPI2(it, b, e) for (auto it = (b); it != (e); ++it)
#define REPI(it, c) REPI2(it, (c).begin(), (c).end())
#define RREPI(it, c) REPI2(it, (c).rbegin(), (c).rend())
#define REPI_ERACE2(it, b, e) for (auto it = (b); it != (e);)
#define REPI_ERACE(it, c) REPI_ERACE2(it, (c).begin(), (c).end())
#define ALL(x) (x).begin(), (x).end()
#define cauto const auto &
/* macro func */
#define SORT(x)                                                                \
  do {                                                                         \
    sort(ALL(x));                                                              \
  } while (false)
#define RSORT(x)                                                               \
  do {                                                                         \
    sort((x).rbegin(), (x).rend());                                            \
  } while (false)
#define UNIQUE(v)                                                              \
  do {                                                                         \
    v.erase(unique(v.begin(), v.end()), v.end());                              \
  } while (false)
#define MAX(x, y)                                                              \
  do {                                                                         \
    x = std::max(x, y);                                                        \
  } while (false)
#define MIN(x, y)                                                              \
  do {                                                                         \
    x = std::min(x, y);                                                        \
  } while (false)
#define BR                                                                     \
  do {                                                                         \
    cout << "\n";                                                              \
  } while (false)

/* type define */
using ll = long long;
using PAIR = std::pair<ll, ll>;
using VS = std::vector<std::string>;
using VL = std::vector<long long>;
using VVL = std::vector<VL>;
using VVVL = std::vector<VVL>;
using VD = std::vector<double>;
template <class T> using V = std::vector<T>;

/* using std */
using std::cout;
constexpr char endl = '\n';
using std::bitset;
using std::cin;
using std::list;
using std::map;
using std::multimap;
using std::multiset;
using std::pair;
using std::priority_queue;
using std::queue;
using std::set;
using std::sort;
using std::stack;
using std::string;
using std::unordered_map;
using std::unordered_multimap;
using std::unordered_multiset;
using std::unordered_set;
using std::vector;

/* constant value */
constexpr ll MOD = 1000000007;
// constexpr ll MOD = 998244353;

/* Initial processing  */
struct Preprocessing {
  Preprocessing() {
    std::cin.tie(0);
    std::ios::sync_with_stdio(0);
  };
} _Preprocessing;

/* Remove the source of the bug */
signed pow(signed, signed) {
  assert(false);
  return -1;
}

/* define hash */
namespace std {
template <> class hash<std::pair<ll, ll>> {
public:
  size_t operator()(const std::pair<ll, ll> &x) const {
    return hash<ll>()(1000000000 * x.first + x.second);
  }
};
} // namespace std

/* input */
template <class T> std::istream &operator>>(std::istream &is, vector<T> &vec) {
  for (T &x : vec)
    is >> x;
  return is;
}

//=============================================================================================

signed main() {
  string str;
  cin >> str;
  ll n;
  cin >> n;

  ll cnt = 0;
  ll sz = str.size();
  VL ans;
  ans.reserve(1e6);
  ll t = 1;

  bool bf = false;
  bool ok = false;
  REP(i, sz - 1) {
    if (str[i] == str[i + 1]) {
      if (bf) {
        bf = false;
        continue;
      }
      ++cnt;
      bf = true;
      if (i == sz - 2) {
        ok = true;
      }
    } else {
      bf = false;
    }
  }
  if (str[0] != str[sz - 1]) {
    ok = true;
  }
  ans.emplace_back(cnt);
  while (!ok) {
    ++t;
    REP(i, sz) {
      if (str[(i - 1 + sz) % sz] == str[i]) {
        if (bf) {
          bf = false;
          continue;
        }
        ++cnt;
        bf = true;
        if (i == sz - 1) {
          ok = true;
        }
      } else {
        bf = false;
      }
    }
    ans.emplace_back(cnt);
  }
  ll p = cnt * (n / t);
  dump(p);
  ll c = (n % t) - 1;
  if (c >= 0) {
    p += ans[c];
  }
  cout << p << endl;
}

Fixed submission:
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#ifdef DEBUG
#include "./Lib/debug.hpp"
#else
#define dump(...)
template <class T> inline auto d_val(T a, T b) { return a; }
#endif

/* (=＾o＾=) */
#define int ll

/* macro */
#define FOR(i, b, e) for (ll i = (ll)(b); i < (ll)(e); ++i)
#define RFOR(i, b, e) for (ll i = (ll)(e - 1); i >= (ll)(b); --i)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) RFOR(i, 0, n)
#define REPC(x, c) for (const auto &x : (c))
#define REPI2(it, b, e) for (auto it = (b); it != (e); ++it)
#define REPI(it, c) REPI2(it, (c).begin(), (c).end())
#define RREPI(it, c) REPI2(it, (c).rbegin(), (c).rend())
#define REPI_ERACE2(it, b, e) for (auto it = (b); it != (e);)
#define REPI_ERACE(it, c) REPI_ERACE2(it, (c).begin(), (c).end())
#define ALL(x) (x).begin(), (x).end()
#define cauto const auto &
/* macro func */
#define SORT(x)                                                                \
  do {                                                                         \
    sort(ALL(x));                                                              \
  } while (false)
#define RSORT(x)                                                               \
  do {                                                                         \
    sort((x).rbegin(), (x).rend());                                            \
  } while (false)
#define UNIQUE(v)                                                              \
  do {                                                                         \
    v.erase(unique(v.begin(), v.end()), v.end());                              \
  } while (false)
#define MAX(x, y)                                                              \
  do {                                                                         \
    x = std::max(x, y);                                                        \
  } while (false)
#define MIN(x, y)                                                              \
  do {                                                                         \
    x = std::min(x, y);                                                        \
  } while (false)
#define BR                                                                     \
  do {                                                                         \
    cout << "\n";                                                              \
  } while (false)

/* type define */
using ll = long long;
using PAIR = std::pair<ll, ll>;
using VS = std::vector<std::string>;
using VL = std::vector<long long>;
using VVL = std::vector<VL>;
using VVVL = std::vector<VVL>;
using VD = std::vector<double>;
template <class T> using V = std::vector<T>;

/* using std */
using std::cout;
constexpr char endl = '\n';
using std::bitset;
using std::cin;
using std::list;
using std::map;
using std::multimap;
using std::multiset;
using std::pair;
using std::priority_queue;
using std::queue;
using std::set;
using std::sort;
using std::stack;
using std::string;
using std::unordered_map;
using std::unordered_multimap;
using std::unordered_multiset;
using std::unordered_set;
using std::vector;

/* constant value */
constexpr ll MOD = 1000000007;
// constexpr ll MOD = 998244353;

/* Initial processing  */
struct Preprocessing {
  Preprocessing() {
    std::cin.tie(0);
    std::ios::sync_with_stdio(0);
  };
} _Preprocessing;

/* Remove the source of the bug */
signed pow(signed, signed) {
  assert(false);
  return -1;
}

/* define hash */
namespace std {
template <> class hash<std::pair<ll, ll>> {
public:
  size_t operator()(const std::pair<ll, ll> &x) const {
    return hash<ll>()(1000000000 * x.first + x.second);
  }
};
} // namespace std

/* input */
template <class T> std::istream &operator>>(std::istream &is, vector<T> &vec) {
  for (T &x : vec)
    is >> x;
  return is;
}

//=============================================================================================

signed main() {
  string str;
  cin >> str;
  ll n;
  cin >> n;

  ll cnt = 0;
  ll sz = str.size();
  VL ans;
  ans.reserve(1e6);
  ll t = 1;

  bool bf = false;
  bool ok = false;
  REP(i, sz - 1) {
    if (str[i] == str[i + 1]) {
      if (bf) {
        bf = false;
        continue;
      }
      ++cnt;
      bf = true;
      if (i == sz - 2) {
        ok = true;
      }
    } else {
      bf = false;
    }
  }
  if (str[0] != str[sz - 1]) {
    ok = true;
  }
  ans.emplace_back(cnt);
  while (!ok) {
    ++t;
    REP(i, sz) {
      if (str[(i - 1 + sz) % sz] == str[i]) {
        if (bf) {
          bf = false;
          continue;
        }
        ++cnt;
        bf = true;
        if (i == sz - 1) {
          ok = true;
        }
      } else {
        bf = false;
      }
    }
    ans.emplace_back(cnt);
    if (t == n) {
      cout << cnt << endl;
      return 0;
    }
    if (t == 1e3) {
      dump("in");
      ll f = ans[0];
      ll def = ans[101] - ans[100];
      cout << f + def * (n - 1) << endl;
      return 0;
    }
  }
  ll p = cnt * (n / t);
  dump(p);
  ll c = (n % t) - 1;
  if (c >= 0) {
    p += ans[c];
  }
  cout << p << endl;
}