Problem p02630 (C++) — buggy submission, verdict: Time Limit Exceeded

#include <bits/stdc++.h>
#include <boost/range/irange.hpp>
#define RANGE_1(e) (boost::irange(0, (e)))
#define RANGE_2(s, e) (boost::irange((s), (e)))
#define RANGE_3(s, e, step) (boost::irange((s), (e), (step)))
#define RANGE_SELECTER(_1, _2, _3, SELECT, ...) SELECT
#define range(...)                                                             \\
  RANGE_SELECTER(__VA_ARGS__, RANGE_3, RANGE_2, RANGE_1)(__VA_ARGS__)
#define guard(x)                                                               \\
  if (x)                                                                       \\
    ;
#define CINS(x)                                                                \\
  for (auto &&AJNAD : (x))                                                     \\
  cin >> AJNAD
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#define CALL(x) (x).cbegin(), (x).cend()
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define BIT(n) (1LL << (n))
#define MOD 1000000007

using namespace std;
using lint = long long;

// template<class T>class irange{private:struct I{T x;T operator*(){return
// x;}bool operator!=(I&lhs){return x<lhs.x;}void operator++(){++x;}};I
// i,n;public:irange(T i,T n):i({i}),n({n}){}I&begin(){return i;}I&end(){return
// n;}}; template<class T>class srange{private:struct I{T x,s;T
// operator*(){return x;}bool operator!=(I&lhs){if(s<(T)0)return x>lhs.x;return
// x<lhs.x;}void operator++(){x=x+s;}};I i,n;public:srange(T i,T n,T
// s):i({i,s}),n({n,s}){}I&begin(){return i;}I&end(){return n;}}; template<class
// T>irange<T>range(T n){return irange(0,n);}template<class T>irange<T>range(T
// i,T n){return irange(i,n);}template<class T>srange<T>range(T i,T n,T
// s){return srange(i,n,s);}
template <class T> bool amax(T &a, const T &b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <class T> bool amin(T &a, const T &b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}

template <int M> struct modint {
  lint val;
  constexpr modint(lint v = 0) noexcept : val(v % M) {
    if (val < 0)
      val += M;
  }
  constexpr int getM() { return M; }
  constexpr modint operator-() const noexcept { return val ? M - val : 0; }
  constexpr modint operator+(const modint &r) const noexcept {
    return modint(*this) += r;
  }
  constexpr modint operator-(const modint &r) const noexcept {
    return modint(*this) -= r;
  }
  constexpr modint operator*(const modint &r) const noexcept {
    return modint(*this) *= r;
  }
  constexpr modint operator/(const modint &r) const noexcept {
    return modint(*this) /= r;
  }
  constexpr modint &operator+=(const modint &r) noexcept {
    val += r.val;
    if (val >= M)
      val -= M;
    return *this;
  }
  constexpr modint &operator-=(const modint &r) noexcept {
    val -= r.val;
    if (val < 0)
      val += M;
    return *this;
  }
  constexpr modint &operator*=(const modint &r) noexcept {
    val = val * r.val % M;
    return *this;
  }
  constexpr modint &operator/=(const modint &r) noexcept {
    lint a = r.val, b = M, u = 1, v = 0;
    while (b) {
      lint t = a / b;
      a -= t * b;
      swap(a, b);
      u -= t * v;
      swap(u, v);
    }
    val = val * u % M;
    if (val < 0)
      val += M;
    return *this;
  }
  constexpr bool operator==(const modint &r) const noexcept {
    return this->val == r.val;
  }
  constexpr bool operator!=(const modint &r) const noexcept {
    return this->val != r.val;
  }
  friend constexpr istream &operator>>(istream &is, modint<M> &x) noexcept {
    return is >> x.val;
  }
  friend constexpr ostream &operator<<(ostream &os,
                                       const modint<M> &x) noexcept {
    return os << x.val;
  }
  friend constexpr modint<M> Mpow(const modint<M> &a, lint n) noexcept {
    if (n == 0)
      return 1;
    auto t = Mpow(a, n / 2);
    t = t * t;
    if (n & 1)
      t = t * a;
    return t;
  }
};

struct initialize {
  initialize() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
  };
} init;

int main() {
  int n;
  cin >> n;
  vector<int> a(n);
  CINS(a);

  vector<int> num(100000);
  lint sum = 0;
  for (auto &&e : a) {
    num[e] += 1;
    sum += e;
  }

  int b, c;
  int dif;

  int q;
  cin >> q;
  for (int i : range(q)) {
    cin >> b >> c;
    dif = c - b;
    dif *= num[b];
    num[c] += num[b];
    num[b] = 0;
    sum += dif;
    cout << sum << '\\n';
  }
}


Error: TLE

Fixed submission:

#include <bits/stdc++.h>
#include <boost/range/irange.hpp>
#define RANGE_1(e) (boost::irange(0, (e)))
#define RANGE_2(s, e) (boost::irange((s), (e)))
#define RANGE_3(s, e, step) (boost::irange((s), (e), (step)))
#define RANGE_SELECTER(_1, _2, _3, SELECT, ...) SELECT
#define range(...)                                                             \\
  RANGE_SELECTER(__VA_ARGS__, RANGE_3, RANGE_2, RANGE_1)(__VA_ARGS__)
#define guard(x)                                                               \\
  if (x)                                                                       \\
    ;
#define CINS(x)                                                                \\
  for (auto &&__E__ : (x))                                                     \\
  cin >> __E__
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#define CALL(x) (x).cbegin(), (x).cend()
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define BIT(n) (1LL << (n))
#define MOD 1000000007

using namespace std;
using lint = long long;

// template<class T>class irange{private:struct I{T x;T operator*(){return
// x;}bool operator!=(I&lhs){return x<lhs.x;}void operator++(){++x;}};I
// i,n;public:irange(T i,T n):i({i}),n({n}){}I&begin(){return i;}I&end(){return
// n;}}; template<class T>class srange{private:struct I{T x,s;T
// operator*(){return x;}bool operator!=(I&lhs){if(s<(T)0)return x>lhs.x;return
// x<lhs.x;}void operator++(){x=x+s;}};I i,n;public:srange(T i,T n,T
// s):i({i,s}),n({n,s}){}I&begin(){return i;}I&end(){return n;}}; template<class
// T>irange<T>range(T n){return irange(0,n);}template<class T>irange<T>range(T
// i,T n){return irange(i,n);}template<class T>srange<T>range(T i,T n,T
// s){return srange(i,n,s);}
template <class T> bool amax(T &a, const T &b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <class T> bool amin(T &a, const T &b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}

struct initialize {
  initialize() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
  };
} __ini__;

int main() {
  int n;
  cin >> n;
  vector<int> a(n);
  CINS(a);
  sort(ALL(a));

  int q;
  cin >> q;

  int b, c;

  int cnt = 0;

  for (int i : range(q)) {
    cin >> b >> c;
    for (auto e = lower_bound(ALL(a), b); e != a.end();) {
      if (*e == b) {
        a.erase(e);
        ++cnt;
      } else if (*e > b) {
        break;
      }
    }
    auto ci = lower_bound(ALL(a), c);
    for (int j : range(cnt)) {
      a.insert(ci, c);
    }
    cnt = 0;
    cout << accumulate(ALL(a), 0) << '\\n';
  }
}