Problem p02692 (C++) — buggy submission, verdict: 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)
#ifdef ONLINE_JUDGE
#define debug(x)
#define debug2(x, y)
#define debug3(x, y, z)
#define assert(e)                                                              \\
  if (!(e)) {                                                                  \\
    stod("");                                                                  \\
  }
#else
#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"
#endif

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); }

using ull = unsigned long long;
inline void scan(ull &a) { scanf("%llu", &a); }

inline void scan(char &a) { scanf(" %c", &a); }
inline void scan(double &a) { scanf("%lf", &a); }
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 scan(std::string &s) {
  char BUF[3000000];
  scanf(" %s", BUF);
  s = std::string(BUF);
}
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;

void print_(vi &ans) {
  print("Yes");
  for (int a : ans) {
    printf("%c\\n", "ABC"[a]);
  }
  exit(0);
}

vi naive_aux(ll n, vll abc, vi &s) {
  vector<int> ans(n);
  rep(i, n) {
    ll i1 = s[i];
    ll i2 = (s[i] + 1) % 3;
    if (abc[i1] > abc[i2]) {
      swap(i1, i2);
    }
    if (abc[i2] == 0) {
      return (vi){};
    }
    ans[i] = i1;
    abc[i1] += 1;
    abc[i2] -= 1;
  }
  return ans;
}

void naive(ll n, vll abc, vi &s) {
  auto ans = naive_aux(n, abc, s);
  if (ans.empty()) {
    print("No");
  } else {
    print_(ans);
  }
  exit(0);
}

int convert(vll &abc) {
  if (abc[0] == 0) {
    assert(0 <= abc[1] && abc[1] <= 2);
    return abc[1];
  }
  if (abc[0] == 1) {
    assert(0 <= abc[1] && abc[1] <= 1);
    return abc[1] + 3;
  }
  assert(abc[0] == 2);
  return 5;
}

void corner(ll n, vll &abc, vi &s) {
  vvi dp(n + 1, vi(6, 0));
  /* 0: 0,0,2
   * 1: 0,1,1
   * 2: 0,2,0
   * 3: 1,0,1
   * 4: 1,1,0
   * 5: 2,0,0
   */

  vvll hoge = {{0, 0, 2}, {0, 1, 1}, {0, 2, 0},
               {1, 0, 1}, {1, 1, 0}, {2, 0, 0}};
  dp[0][convert(abc)] = 1;

  vector<vvi> fuga = {{{1, 3}, {2, 4}, {3, 1}, {4, 2}, {4, 5}, {5, 4}},
                      {{0, 1}, {1, 0}, {1, 2}, {2, 1}, {3, 4}, {4, 3}},
                      {{0, 3}, {3, 0}, {1, 4}, {4, 1}, {3, 5}, {5, 3}}};

  rep(i, n) {
    auto piyo = fuga[s[i]];
    for (vi prop : piyo) {
      dp[i + 1][prop[1]] |= dp[i][prop[0]];
    }
  }
  int state = -1;
  rep(i, 6) {
    if (dp[n][i]) {
      state = i;
      break;
    }
  }
  if (state == -1) {
    print("No");
    exit(0);
  }
  vi ans(n);
  for (int i = n - 1; i >= 0; --i) {
    auto piyo = fuga[s[i]];
    for (vi prop : piyo) {
      int p0 = prop[0];
      int p1 = prop[1];
      if (dp[i][p0] == 0) {
        continue;
      }
      if (p1 != state) {
        continue;
      }
      rep(j, 3) {
        if (hoge[p0][j] < hoge[p1][j]) {
          ans[i] = j;
        }
      }
      state = p0;
      break;
    }
  }
  print_(ans);
  exit(0);
}

void solve() {
  ll n;
  vll abc(3);
  scan(n);
  scan(abc);
  vi s(n);
  rep(i, n) {
    string st;
    scan(st);
    if (st == "AB") {
      s[i] = 0;
    } else if (st == "BC") {
      s[i] = 1;
    } else {
      s[i] = 2;
    }
  }
  int zeros = 0;
  ll sum_abc = 0;
  rep(i, 3) {
    if (abc[i] == 0) {
      zeros += 1;
    }
    sum_abc += abc[i];
  }

  if (sum_abc == 0) {
    print("No");
    exit(0);
  }
  if (sum_abc == 1) {
    naive(n, abc, s);
  }
  if (zeros == 0 || (zeros == 1 && sum_abc >= 3)) {
    naive(n, abc, s);
  }
  if (zeros == 2 && sum_abc >= 3) {
    if (abc[s[0]] > 0 || abc[(s[0] + 1) % 3] > 0) {
      naive(n, abc, s);
    } else {
      print("No");
      exit(0);
    }
  }
  debug(abc);
  assert(sum_abc == 2);
  corner(n, abc, s);
}

int main() {
  solve();
  return 0;
}


Error: 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)
#ifdef ONLINE_JUDGE
#define debug(x)
#define debug2(x, y)
#define debug3(x, y, z)
#define assert(e)                                                              \\
  if (!(e)) {                                                                  \\
    stod("");                                                                  \\
  }
#else
#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"
#endif

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); }

using ull = unsigned long long;
inline void scan(ull &a) { scanf("%llu", &a); }

inline void scan(char &a) { scanf(" %c", &a); }
inline void scan(double &a) { scanf("%lf", &a); }
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 scan(std::string &s) {
  char BUF[3000000];
  scanf(" %s", BUF);
  s = std::string(BUF);
}
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;

void print_(vi &ans) {
  print("Yes");
  for (int a : ans) {
    printf("%c\\n", "ABC"[a]);
  }
  exit(0);
}

vi naive_aux(ll n, vll abc, vi &s) {
  vector<int> ans(n);
  rep(i, n) {
    ll i1 = s[i];
    ll i2 = (s[i] + 1) % 3;
    if (abc[i1] > abc[i2]) {
      swap(i1, i2);
    }
    if (abc[i2] == 0) {
      return (vi){};
    }
    ans[i] = i1;
    abc[i1] += 1;
    abc[i2] -= 1;
  }
  return ans;
}

void naive(ll n, vll abc, vi &s) {
  auto ans = naive_aux(n, abc, s);
  if (ans.empty()) {
    print("No");
  } else {
    print_(ans);
  }
  exit(0);
}

int convert(vll &abc) {
  if (abc[0] == 0) {
    // assert (0 <= abc[1] && abc[1] <= 2);
    return abc[1];
  }
  if (abc[1] == 1) {
    // assert (0 <= abc[1] && abc[1] <= 1);
    return abc[1] + 3;
  }
  assert(abc[0] == 2LL);
  return 5;
}

void corner(ll n, vll &abc, vi &s) {
  vvi dp(n + 1, vi(6, 0));
  /* 0: 0,0,2
   * 1: 0,1,1
   * 2: 0,2,0
   * 3: 1,0,1
   * 4: 1,1,0
   * 5: 2,0,0
   */

  vvll hoge = {{0, 0, 2}, {0, 1, 1}, {0, 2, 0},
               {1, 0, 1}, {1, 1, 0}, {2, 0, 0}};
  dp[0][convert(abc)] = 1;

  vector<vvi> fuga = {{{1, 3}, {2, 4}, {3, 1}, {4, 2}, {4, 5}, {5, 4}},
                      {{0, 1}, {1, 0}, {1, 2}, {2, 1}, {3, 4}, {4, 3}},
                      {{0, 3}, {3, 0}, {1, 4}, {4, 1}, {3, 5}, {5, 3}}};

  rep(i, n) {
    auto piyo = fuga[s[i]];
    for (vi prop : piyo) {
      dp[i + 1][prop[1]] |= dp[i][prop[0]];
    }
  }
  int state = -1;
  rep(i, 6) {
    if (dp[n][i]) {
      state = i;
      break;
    }
  }
  if (state == -1) {
    print("No");
    exit(0);
  }
  vi ans(n);
  for (int i = n - 1; i >= 0; --i) {
    auto piyo = fuga[s[i]];
    for (vi prop : piyo) {
      int p0 = prop[0];
      int p1 = prop[1];
      if (dp[i][p0] == 0) {
        continue;
      }
      if (p1 != state) {
        continue;
      }
      rep(j, 3) {
        if (hoge[p0][j] < hoge[p1][j]) {
          ans[i] = j;
        }
      }
      state = p0;
      break;
    }
  }
  print_(ans);
  exit(0);
}

void solve() {
  ll n;
  vll abc(3);
  scan(n);
  scan(abc);
  vi s(n);
  rep(i, n) {
    string st;
    scan(st);
    if (st == "AB") {
      s[i] = 0;
    } else if (st == "BC") {
      s[i] = 1;
    } else {
      s[i] = 2;
    }
  }
  int zeros = 0;
  ll sum_abc = 0;
  rep(i, 3) {
    if (abc[i] == 0) {
      zeros += 1;
    }
    sum_abc += abc[i];
  }

  if (sum_abc == 0) {
    print("No");
    exit(0);
  }
  if (sum_abc == 1) {
    naive(n, abc, s);
  }
  if (zeros == 0 || (zeros == 1 && sum_abc >= 3)) {
    naive(n, abc, s);
  }
  if (zeros == 2 && sum_abc >= 3) {
    if (abc[s[0]] > 0 || abc[(s[0] + 1) % 3] > 0) {
      naive(n, abc, s);
    } else {
      print("No");
      exit(0);
    }
  }
  debug(abc);
  assert(sum_abc == 2);
  corner(n, abc, s);
}

int main() {
  solve();
  return 0;
}