Problem p02557 (C++)

Buggy submission (status: Runtime Error):
#include <bits/stdc++.h>
using namespace std;
using ll = long long;

#ifdef LOCAL_TEST
#define BOOST_STACKTRACE_USE_ADDR2LINE
#define BOOST_STACKTRACE_ADDR2LINE_LOCATION                                    \
  / usr / local / opt / binutils / bin / addr2line
#define _GNU_SOURCE 1
#include <boost/stacktrace.hpp>
namespace std {
template <typename T> class dvector : public std::vector<T> {
public:
  dvector() : std::vector<T>() {}
  explicit dvector(size_t n, const T &value = T()) : std::vector<T>(n, value) {}
  dvector(const std::vector<T> &v) : std::vector<T>(v) {}
  dvector(const std::initializer_list<T> il) : std::vector<T>(il) {}
  dvector(const std::string::iterator first, const std::string::iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::iterator first,
          const typename std::vector<T>::iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::reverse_iterator first,
          const typename std::vector<T>::reverse_iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::const_iterator first,
          const typename std::vector<T>::const_iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::const_reverse_iterator first,
          const typename std::vector<T>::const_reverse_iterator last)
      : std::vector<T>(first, last) {}
  T &operator[](size_t n) {
    try {
      return this->at(n);
    } catch (const std::exception &e) {
      std::cerr << boost::stacktrace::stacktrace() << '\n';
      return this->at(n);
    }
  }
  const T &operator[](size_t n) const {
    try {
      return this->at(n);
    } catch (const std::exception &e) {
      std::cerr << boost::stacktrace::stacktrace() << '\n';
      return this->at(n);
    }
  }
};
} // namespace std
class dbool {
private:
  bool boolvalue;

public:
  dbool() : boolvalue(false) {}
  dbool(bool b) : boolvalue(b) {}
  operator bool &() { return boolvalue; }
  operator const bool &() const { return boolvalue; }
};
#define vector dvector
#define bool dbool
class SIGFPE_exception : std::exception {};
class SIGSEGV_exception : std::exception {};
void catch_SIGFPE([[maybe_unused]] int e) {
  std::cerr << boost::stacktrace::stacktrace() << '\n';
  throw SIGFPE_exception();
}
void catch_SIGSEGV([[maybe_unused]] int e) {
  std::cerr << boost::stacktrace::stacktrace() << '\n';
  throw SIGSEGV_exception();
}
signed convertedmain();
signed main() {
  signal(SIGFPE, catch_SIGFPE);
  signal(SIGSEGV, catch_SIGSEGV);
  return convertedmain();
}
#define main() convertedmain()
#endif
#ifdef LOCAL_DEV
template <typename T1, typename T2>
std::ostream &operator<<(std::ostream &s, const std::pair<T1, T2> &p) {
  return s << "(" << p.first << ", " << p.second << ")";
}
template <typename T, size_t N>
std::ostream &operator<<(std::ostream &s, const std::array<T, N> &a) {
  s << "{ ";
  for (size_t i = 0; i < N; ++i) {
    s << a[i] << "\t";
  }
  s << "}";
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::set<T> &se) {
  s << "{ ";
  for (auto itr = se.begin(); itr != se.end(); ++itr) {
    s << (*itr) << "\t";
  }
  s << "}";
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::multiset<T> &se) {
  s << "{ ";
  for (auto itr = se.begin(); itr != se.end(); ++itr) {
    s << (*itr) << "\t";
  }
  s << "}";
  return s;
}
template <typename T1, typename T2>
std::ostream &operator<<(std::ostream &s, const std::map<T1, T2> &m) {
  s << "{\n";
  for (auto itr = m.begin(); itr != m.end(); ++itr) {
    s << "\t" << (*itr).first << " : " << (*itr).second << "\n";
  }
  s << "}";
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::deque<T> &v) {
  for (size_t i = 0; i < v.size(); ++i) {
    s << v[i];
    if (i < v.size() - 1)
      s << "\t";
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::vector<T> &v) {
  for (size_t i = 0; i < v.size(); ++i) {
    s << v[i];
    if (i < v.size() - 1)
      s << "\t";
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s,
                         const std::vector<std::vector<T>> &vv) {
  s << "\\\n";
  for (size_t i = 0; i < vv.size(); ++i) {
    s << vv[i] << "\n";
  }
  return s;
}
void debug_impl() { std::cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_impl(Head head, Tail... tail) {
  std::cerr << " " << head << (sizeof...(tail) ? "," : "");
  debug_impl(tail...);
}
#define debug(...)                                                             \
  do {                                                                         \
    std::cerr << ":" << __LINE__ << " (" << #__VA_ARGS__ << ") =";             \
    debug_impl(__VA_ARGS__);                                                   \
  } while (false)
#else
#define debug(...)                                                             \
  do {                                                                         \
  } while (false)
#endif

int main() {
  ll N;
  cin >> N;
  vector<ll> a(N), b(N);
  for (ll i = 0; i < N; i++)
    cin >> a[i];
  for (ll i = 0; i < N; i++)
    cin >> b[i];

  map<ll, ll> am, bm;
  for (ll i = 0; i < N; i++) {
    am[a[i]]++;
    bm[b[i]]++;
  }
  for (auto &&pr : am) {
    if (pr.second + bm[pr.first] > N) {
      cout << "No\n";
      return 0;
    }
  }

  vector<pair<ll, ll>> ans;
  priority_queue<array<ll, 4>> q; //(a+bの要素数, aの要素数, bの要素数, 値)
  vector<ll> onlya, onlyb;
  for (auto &&pr : am) {
    ll acount = am[pr.first];
    ll bcount = bm[pr.first];
    if (bcount) {
      q.push({acount + bcount, acount, bcount, pr.first});
    } else {
      for (ll i = 0; i < pr.second; i++)
        onlya.push_back(pr.first);
    }
  }
  for (auto &&pr : bm) {
    if (am[pr.first])
      continue;
    for (ll i = 0; i < pr.first; i++)
      onlyb.push_back(pr.second);
  }

  while ((ll)q.size() >= 2) {
    array<ll, 4> x = q.top();
    q.pop();
    array<ll, 4> y = q.top();
    q.pop();
    x[0]--;
    y[0]--;
    x[1]--;
    y[2]--;
    ans.push_back({x[3], y[3]});
    if (x[1] == 0 || x[2] == 0) {
      if (x[1] > 0)
        for (ll i = 0; i < x[1]; i++)
          onlya.push_back(x[3]);
      if (x[2] > 0)
        for (ll i = 0; i < x[2]; i++)
          onlyb.push_back(x[3]);
    } else {
      q.push(x);
    }
    if (y[1] == 0 || y[2] == 0) {
      if (y[1] > 0)
        for (ll i = 0; i < y[1]; i++)
          onlya.push_back(y[3]);
      if (y[2] > 0)
        for (ll i = 0; i < y[2]; i++)
          onlyb.push_back(y[3]);
    } else {
      q.push(y);
    }
  }

  while (!q.empty()) {
    array<ll, 4> x = q.top();
    q.pop();
    for (ll i = 0; i < x[1]; i++) {
      ans.push_back({x[3], onlyb.back()});
      onlyb.pop_back();
    }
    for (ll i = 0; i < x[2]; i++) {
      ans.push_back({onlya.back(), x[3]});
      onlya.pop_back();
    }
  }

  for (ll i = 0; i < (ll)onlya.size(); i++) {
    ans.push_back({onlya[i], onlyb[i]});
  }
  debug(onlya);
  debug(onlyb);
  debug(ans);

  sort(ans.begin(), ans.end());
  cout << "Yes\n";
  for (ll i = 0; i < N; i++)
    cout << ans[i].second << " \n"[i == N - 1];

  return 0;
}


Fixed submission:
#include <bits/stdc++.h>
using namespace std;
using ll = long long;

#ifdef LOCAL_TEST
#define BOOST_STACKTRACE_USE_ADDR2LINE
#define BOOST_STACKTRACE_ADDR2LINE_LOCATION                                    \
  / usr / local / opt / binutils / bin / addr2line
#define _GNU_SOURCE 1
#include <boost/stacktrace.hpp>
namespace std {
template <typename T> class dvector : public std::vector<T> {
public:
  dvector() : std::vector<T>() {}
  explicit dvector(size_t n, const T &value = T()) : std::vector<T>(n, value) {}
  dvector(const std::vector<T> &v) : std::vector<T>(v) {}
  dvector(const std::initializer_list<T> il) : std::vector<T>(il) {}
  dvector(const std::string::iterator first, const std::string::iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::iterator first,
          const typename std::vector<T>::iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::reverse_iterator first,
          const typename std::vector<T>::reverse_iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::const_iterator first,
          const typename std::vector<T>::const_iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::const_reverse_iterator first,
          const typename std::vector<T>::const_reverse_iterator last)
      : std::vector<T>(first, last) {}
  T &operator[](size_t n) {
    try {
      return this->at(n);
    } catch (const std::exception &e) {
      std::cerr << boost::stacktrace::stacktrace() << '\n';
      return this->at(n);
    }
  }
  const T &operator[](size_t n) const {
    try {
      return this->at(n);
    } catch (const std::exception &e) {
      std::cerr << boost::stacktrace::stacktrace() << '\n';
      return this->at(n);
    }
  }
};
} // namespace std
class dbool {
private:
  bool boolvalue;

public:
  dbool() : boolvalue(false) {}
  dbool(bool b) : boolvalue(b) {}
  operator bool &() { return boolvalue; }
  operator const bool &() const { return boolvalue; }
};
#define vector dvector
#define bool dbool
class SIGFPE_exception : std::exception {};
class SIGSEGV_exception : std::exception {};
void catch_SIGFPE([[maybe_unused]] int e) {
  std::cerr << boost::stacktrace::stacktrace() << '\n';
  throw SIGFPE_exception();
}
void catch_SIGSEGV([[maybe_unused]] int e) {
  std::cerr << boost::stacktrace::stacktrace() << '\n';
  throw SIGSEGV_exception();
}
signed convertedmain();
signed main() {
  signal(SIGFPE, catch_SIGFPE);
  signal(SIGSEGV, catch_SIGSEGV);
  return convertedmain();
}
#define main() convertedmain()
#endif
#ifdef LOCAL_DEV
template <typename T1, typename T2>
std::ostream &operator<<(std::ostream &s, const std::pair<T1, T2> &p) {
  return s << "(" << p.first << ", " << p.second << ")";
}
template <typename T, size_t N>
std::ostream &operator<<(std::ostream &s, const std::array<T, N> &a) {
  s << "{ ";
  for (size_t i = 0; i < N; ++i) {
    s << a[i] << "\t";
  }
  s << "}";
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::set<T> &se) {
  s << "{ ";
  for (auto itr = se.begin(); itr != se.end(); ++itr) {
    s << (*itr) << "\t";
  }
  s << "}";
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::multiset<T> &se) {
  s << "{ ";
  for (auto itr = se.begin(); itr != se.end(); ++itr) {
    s << (*itr) << "\t";
  }
  s << "}";
  return s;
}
template <typename T1, typename T2>
std::ostream &operator<<(std::ostream &s, const std::map<T1, T2> &m) {
  s << "{\n";
  for (auto itr = m.begin(); itr != m.end(); ++itr) {
    s << "\t" << (*itr).first << " : " << (*itr).second << "\n";
  }
  s << "}";
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::deque<T> &v) {
  for (size_t i = 0; i < v.size(); ++i) {
    s << v[i];
    if (i < v.size() - 1)
      s << "\t";
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::vector<T> &v) {
  for (size_t i = 0; i < v.size(); ++i) {
    s << v[i];
    if (i < v.size() - 1)
      s << "\t";
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s,
                         const std::vector<std::vector<T>> &vv) {
  s << "\\\n";
  for (size_t i = 0; i < vv.size(); ++i) {
    s << vv[i] << "\n";
  }
  return s;
}
void debug_impl() { std::cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_impl(Head head, Tail... tail) {
  std::cerr << " " << head << (sizeof...(tail) ? "," : "");
  debug_impl(tail...);
}
#define debug(...)                                                             \
  do {                                                                         \
    std::cerr << ":" << __LINE__ << " (" << #__VA_ARGS__ << ") =";             \
    debug_impl(__VA_ARGS__);                                                   \
  } while (false)
#else
#define debug(...)                                                             \
  do {                                                                         \
  } while (false)
#endif

int main() {
  ll N;
  cin >> N;
  vector<ll> a(N), b(N);
  for (ll i = 0; i < N; i++)
    cin >> a[i];
  for (ll i = 0; i < N; i++)
    cin >> b[i];

  map<ll, ll> am, bm;
  for (ll i = 0; i < N; i++) {
    am[a[i]]++;
    bm[b[i]]++;
  }
  for (auto &&pr : am) {
    if (pr.second + bm[pr.first] > N) {
      cout << "No\n";
      return 0;
    }
  }

  vector<pair<ll, ll>> ans;
  priority_queue<array<ll, 4>> q; //(a+bの要素数, aの要素数, bの要素数, 値)
  vector<ll> onlya, onlyb;
  for (auto &&pr : am) {
    ll acount = am[pr.first];
    ll bcount = bm[pr.first];
    if (bcount) {
      q.push({acount + bcount, acount, bcount, pr.first});
    } else {
      for (ll i = 0; i < pr.second; i++)
        onlya.push_back(pr.first);
    }
  }
  for (auto &&pr : bm) {
    if (am[pr.first])
      continue;
    for (ll i = 0; i < pr.second; i++)
      onlyb.push_back(pr.first);
  }

  while ((ll)q.size() >= 2) {
    array<ll, 4> x = q.top();
    q.pop();
    array<ll, 4> y = q.top();
    q.pop();
    x[0]--;
    y[0]--;
    x[1]--;
    y[2]--;
    ans.push_back({x[3], y[3]});
    if (x[1] == 0 || x[2] == 0) {
      if (x[1] > 0)
        for (ll i = 0; i < x[1]; i++)
          onlya.push_back(x[3]);
      if (x[2] > 0)
        for (ll i = 0; i < x[2]; i++)
          onlyb.push_back(x[3]);
    } else {
      q.push(x);
    }
    if (y[1] == 0 || y[2] == 0) {
      if (y[1] > 0)
        for (ll i = 0; i < y[1]; i++)
          onlya.push_back(y[3]);
      if (y[2] > 0)
        for (ll i = 0; i < y[2]; i++)
          onlyb.push_back(y[3]);
    } else {
      q.push(y);
    }
  }

  while (!q.empty()) {
    array<ll, 4> x = q.top();
    q.pop();
    for (ll i = 0; i < x[1]; i++) {
      ans.push_back({x[3], onlyb.back()});
      onlyb.pop_back();
    }
    for (ll i = 0; i < x[2]; i++) {
      ans.push_back({onlya.back(), x[3]});
      onlya.pop_back();
    }
  }

  for (ll i = 0; i < (ll)onlya.size(); i++) {
    ans.push_back({onlya[i], onlyb[i]});
  }
  debug(onlya);
  debug(onlyb);
  debug(ans);

  sort(ans.begin(), ans.end());
  cout << "Yes\n";
  for (ll i = 0; i < N; i++)
    cout << ans[i].second << " \n"[i == N - 1];

  return 0;
}