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

#pragma region include
#include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
#define dump(x)                                                                \\
  cerr << #x << " = " << (x) << " [" << __LINE__ << ":" << __FUNCTION__        \\
       << "] " << endl;
// vector出力
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) {
  os << "{";
  for (int i = 0; i < (int)v.size(); i++) {
    os << v[i] << (i < v.size() - 1 ? ", " : "");
  }
  os << "}";
  return os;
}
// pair出力
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &p) {
  return os << "(" << p.first << ", " << p.second << ")";
}
// map出力
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &map_var) {
  os << "{";
  for (auto itr = map_var.begin(); itr != map_var.end(); itr++) {
    os << "(" << itr->first << ", " << itr->second << ")";
    itr++;
    if (itr != map_var.end())
      os << ", ";
    itr--;
  }
  os << "}";
  return os;
}
// set 出力
template <typename T> ostream &operator<<(ostream &os, set<T> &set_var) {
  os << "{";
  for (auto itr = set_var.begin(); itr != set_var.end(); itr++) {
    os << *itr;
    ++itr;
    if (itr != set_var.end())
      os << ", ";
    itr--;
  }
  os << "}";
  return os;
}
#pragma endregion

/////////////////////////////////////////

template <int MOD> struct mint {
public:
  long long x;
  mint(long long x = 0) : x((x % MOD + MOD) % MOD) {}
  mint(std::string &s) {
    long long z = 0;
    for (int i = 0; i < s.size(); i++) {
      z *= 10;
      z += s[i] - '0';
      z %= MOD;
    }
    this->x = z;
  }
  mint &operator+=(const mint &a) {
    if ((x += a.x) >= MOD)
      x -= MOD;
    return *this;
  }
  mint &operator-=(const mint &a) {
    if ((x += MOD - a.x) >= MOD)
      x -= MOD;
    return *this;
  }
  mint &operator*=(const mint &a) {
    (x *= a.x) %= MOD;
    return *this;
  }
  mint &operator/=(const mint &a) {
    long long n = MOD - 2;
    mint u = 1, b = a;
    while (n > 0) {
      if (n & 1) {
        u *= b;
      }
      b *= b;
      n >>= 1;
    }
    return *this *= u;
  }
  mint operator+(const mint &a) const {
    mint res(*this);
    return res += a;
  }
  mint operator-() const { return mint() -= *this; }
  mint operator-(const mint &a) const {
    mint res(*this);
    return res -= a;
  }
  mint operator*(const mint &a) const {
    mint res(*this);
    return res *= a;
  }
  mint operator/(const mint &a) const {
    mint res(*this);
    return res /= a;
  }
  friend std::ostream &operator<<(std::ostream &os, const mint &n) {
    return os << n.x;
  }
  friend std::istream &operator>>(std::istream &is, mint &n) {
    long long x;
    is >> x;
    n = mint(x);
    return is;
  }
  bool operator==(const mint &a) const { return this->x == a.x; }
  mint pow(long long k) const {
    mint ret = 1;
    mint p = this->x;
    while (k > 0) {
      if (k & 1) {
        ret *= p;
      }
      p *= p;
      k >>= 1;
    }
    return ret;
  }
};

template <class S, S (*op)(S, S), S (*e)(), class F, S (*mapping)(F, S),
          F (*composition)(F, F), F (*id)()>
struct lazy_segtree {
public:
  lazy_segtree() : lazy_segtree(0) {}
  lazy_segtree(int n) : lazy_segtree(std::vector<S>(n, e())) {}
  lazy_segtree(const std::vector<S> &v) : _n(int(v.size())) {
    log = 0;
    while ((1U << log) < (unsigned int)(_n))
      log++;
    size = 1 << log;
    d = std::vector<S>(2 * size, e());
    lz = std::vector<F>(size, id());
    for (int i = 0; i < _n; i++)
      d[size + i] = v[i];
    for (int i = size - 1; i >= 1; i--) {
      update(i);
    }
  }
  void set(int p, S x) {
    assert(0 <= p && p < _n);
    p += size;
    for (int i = log; i >= 1; i--)
      push(p >> i);
    d[p] = x;
    for (int i = 1; i <= log; i++)
      update(p >> i);
  }
  S get(int p) {
    assert(0 <= p && p < _n);
    p += size;
    for (int i = log; i >= 1; i--)
      push(p >> i);
    return d[p];
  }
  S prod(int l, int r) {
    assert(0 <= l && l <= r && r <= _n);
    if (l == r)
      return e();
    l += size;
    r += size;
    for (int i = log; i >= 1; i--) {
      if (((l >> i) << i) != l)
        push(l >> i);
      if (((r >> i) << i) != r)
        push(r >> i);
    }
    S sml = e(), smr = e();
    while (l < r) {
      if (l & 1)
        sml = op(sml, d[l++]);
      if (r & 1)
        smr = op(d[--r], smr);
      l >>= 1;
      r >>= 1;
    }
    return op(sml, smr);
  }
  S all_prod() { return d[1]; }
  void apply(int p, F f) {
    assert(0 <= p && p < _n);
    p += size;
    for (int i = log; i >= 1; i--)
      push(p >> i);
    d[p] = mapping(f, d[p]);
    for (int i = 1; i <= log; i++)
      update(p >> i);
  }
  void apply(int l, int r, F f) {
    assert(0 <= l && l <= r && r <= _n);
    if (l == r)
      return;
    l += size;
    r += size;
    for (int i = log; i >= 1; i--) {
      if (((l >> i) << i) != l)
        push(l >> i);
      if (((r >> i) << i) != r)
        push((r - 1) >> i);
    }
    {
      int l2 = l, r2 = r;
      while (l < r) {
        if (l & 1)
          all_apply(l++, f);
        if (r & 1)
          all_apply(--r, f);
        l >>= 1;
        r >>= 1;
      }
      l = l2;
      r = r2;
    }
    for (int i = 1; i <= log; i++) {
      if (((l >> i) << i) != l)
        update(l >> i);
      if (((r >> i) << i) != r)
        update((r - 1) >> i);
    }
  }
  template <bool (*g)(S)> int max_right(int l) {
    return max_right(l, [](S x) { return g(x); });
  }
  template <class G> int max_right(int l, G g) {
    assert(0 <= l && l <= _n);
    assert(g(e()));
    if (l == _n)
      return _n;
    l += size;
    for (int i = log; i >= 1; i--)
      push(l >> i);
    S sm = e();
    do {
      while (l % 2 == 0)
        l >>= 1;
      if (!g(op(sm, d[l]))) {
        while (l < size) {
          push(l);
          l = (2 * l);
          if (g(op(sm, d[l]))) {
            sm = op(sm, d[l]);
            l++;
          }
        }
        return l - size;
      }
      sm = op(sm, d[l]);
      l++;
    } while ((l & -l) != l);
    return _n;
  }
  template <bool (*g)(S)> int min_left(int r) {
    return min_left(r, [](S x) { return g(x); });
  }
  template <class G> int min_left(int r, G g) {
    assert(0 <= r && r <= _n);
    assert(g(e()));
    if (r == 0)
      return 0;
    r += size;
    for (int i = log; i >= 1; i--)
      push((r - 1) >> i);
    S sm = e();
    do {
      r--;
      while (r > 1 && (r % 2))
        r >>= 1;
      if (!g(op(d[r], sm))) {
        while (r < size) {
          push(r);
          r = (2 * r + 1);
          if (g(op(d[r], sm))) {
            sm = op(d[r], sm);
            r--;
          }
        }
        return r + 1 - size;
      }
      sm = op(d[r], sm);
    } while ((r & -r) != r);
    return 0;
  }

private:
  int _n, size, log;
  std::vector<S> d;
  std::vector<F> lz;
  void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
  void all_apply(int k, F f) {
    d[k] = mapping(f, d[k]);
    if (k < size)
      lz[k] = composition(f, lz[k]);
  }
  void push(int k) {
    all_apply(2 * k, lz[k]);
    all_apply(2 * k + 1, lz[k]);
    lz[k] = id();
  }
};

constexpr int MOD = 998244353;
int n;

vector<mint<MOD>> power;
mint<MOD> inv;

// モノイド(S,op,e)
struct S {
  mint<MOD> val;
  int left, right;
};
// 作用素
struct F {
  int a;
};
// S×S->S
S op(S l, S r) {
  return S{l.val + r.val, min(l.left, r.left), max(l.right, r.right)};
}
// 単位元
S e() { return S{0, 1000000000, 0}; }
// f(s)
// f(op(x,y)) = op(f(x),f(y))を満たす必要がある
S mapping(F f, S s) {
  if (f.a == -1)
    return s;
  // cout << f.a << " " << s.val << " " << s.left << " " << s.right << endl;
  return S{power[n - s.right] * (power[s.right - s.left] - 1) * inv * f.a,
           s.left, s.right};
}
// f(g(x))となるF
F composition(F f, F g) { return f.a != -1 ? F{f.a} : F{g.a}; }
// id(x)=xとなるF
F id() { return F{-1}; }

int main() {
  int q;
  cin >> n >> q;
  vector<S> a(n);
  power.resize(n + 1);
  power[0] = 1;
  inv = mint<MOD>(1) / 9;
  for (int i = 0; i < n; i++) {
    power[i + 1] = power[i] * 10;
  }
  for (int i = 0; i < n; i++) {
    a[i].val = mint<MOD>(10).pow(n - i - 1);
    a[i].left = i;
    a[i].right = i + 1;
  }
  lazy_segtree<S, op, e, F, mapping, composition, id> seg(a);
  for (int i = 0; i < q; i++) {
    int l, r, d;
    cin >> l >> r >> d;
    seg.apply(l - 1, r, F{d});
    cout << seg.prod(0, n).val << endl;
  }
  return 0;
}

/////////////////////////////////////////

Error: TLE

Fixed submission:

#pragma region include
#include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
#define dump(x)                                                                \\
  cerr << #x << " = " << (x) << " [" << __LINE__ << ":" << __FUNCTION__        \\
       << "] " << endl;
// vector出力
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) {
  os << "{";
  for (int i = 0; i < (int)v.size(); i++) {
    os << v[i] << (i < v.size() - 1 ? ", " : "");
  }
  os << "}";
  return os;
}
// pair出力
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &p) {
  return os << "(" << p.first << ", " << p.second << ")";
}
// map出力
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &map_var) {
  os << "{";
  for (auto itr = map_var.begin(); itr != map_var.end(); itr++) {
    os << "(" << itr->first << ", " << itr->second << ")";
    itr++;
    if (itr != map_var.end())
      os << ", ";
    itr--;
  }
  os << "}";
  return os;
}
// set 出力
template <typename T> ostream &operator<<(ostream &os, set<T> &set_var) {
  os << "{";
  for (auto itr = set_var.begin(); itr != set_var.end(); itr++) {
    os << *itr;
    ++itr;
    if (itr != set_var.end())
      os << ", ";
    itr--;
  }
  os << "}";
  return os;
}
#pragma endregion

/////////////////////////////////////////

template <int MOD> struct mint {
public:
  long long x;
  mint(long long x = 0) : x((x % MOD + MOD) % MOD) {}
  mint(std::string &s) {
    long long z = 0;
    for (int i = 0; i < s.size(); i++) {
      z *= 10;
      z += s[i] - '0';
      z %= MOD;
    }
    this->x = z;
  }
  mint &operator+=(const mint &a) {
    if ((x += a.x) >= MOD)
      x -= MOD;
    return *this;
  }
  mint &operator-=(const mint &a) {
    if ((x += MOD - a.x) >= MOD)
      x -= MOD;
    return *this;
  }
  mint &operator*=(const mint &a) {
    (x *= a.x) %= MOD;
    return *this;
  }
  mint &operator/=(const mint &a) {
    long long n = MOD - 2;
    mint u = 1, b = a;
    while (n > 0) {
      if (n & 1) {
        u *= b;
      }
      b *= b;
      n >>= 1;
    }
    return *this *= u;
  }
  mint operator+(const mint &a) const {
    mint res(*this);
    return res += a;
  }
  mint operator-() const { return mint() -= *this; }
  mint operator-(const mint &a) const {
    mint res(*this);
    return res -= a;
  }
  mint operator*(const mint &a) const {
    mint res(*this);
    return res *= a;
  }
  mint operator/(const mint &a) const {
    mint res(*this);
    return res /= a;
  }
  friend std::ostream &operator<<(std::ostream &os, const mint &n) {
    return os << n.x;
  }
  friend std::istream &operator>>(std::istream &is, mint &n) {
    long long x;
    is >> x;
    n = mint(x);
    return is;
  }
  bool operator==(const mint &a) const { return this->x == a.x; }
  mint pow(long long k) const {
    mint ret = 1;
    mint p = this->x;
    while (k > 0) {
      if (k & 1) {
        ret *= p;
      }
      p *= p;
      k >>= 1;
    }
    return ret;
  }
};

template <class S, S (*op)(S, S), S (*e)(), class F, S (*mapping)(F, S),
          F (*composition)(F, F), F (*id)()>
struct lazy_segtree {
public:
  lazy_segtree() : lazy_segtree(0) {}
  lazy_segtree(int n) : lazy_segtree(std::vector<S>(n, e())) {}
  lazy_segtree(const std::vector<S> &v) : _n(int(v.size())) {
    log = 0;
    while ((1U << log) < (unsigned int)(_n))
      log++;
    size = 1 << log;
    d = std::vector<S>(2 * size, e());
    lz = std::vector<F>(size, id());
    for (int i = 0; i < _n; i++)
      d[size + i] = v[i];
    for (int i = size - 1; i >= 1; i--) {
      update(i);
    }
  }
  void set(int p, S x) {
    assert(0 <= p && p < _n);
    p += size;
    for (int i = log; i >= 1; i--)
      push(p >> i);
    d[p] = x;
    for (int i = 1; i <= log; i++)
      update(p >> i);
  }
  S get(int p) {
    assert(0 <= p && p < _n);
    p += size;
    for (int i = log; i >= 1; i--)
      push(p >> i);
    return d[p];
  }
  S prod(int l, int r) {
    assert(0 <= l && l <= r && r <= _n);
    if (l == r)
      return e();
    l += size;
    r += size;
    for (int i = log; i >= 1; i--) {
      if (((l >> i) << i) != l)
        push(l >> i);
      if (((r >> i) << i) != r)
        push(r >> i);
    }
    S sml = e(), smr = e();
    while (l < r) {
      if (l & 1)
        sml = op(sml, d[l++]);
      if (r & 1)
        smr = op(d[--r], smr);
      l >>= 1;
      r >>= 1;
    }
    return op(sml, smr);
  }
  S all_prod() { return d[1]; }
  void apply(int p, F f) {
    assert(0 <= p && p < _n);
    p += size;
    for (int i = log; i >= 1; i--)
      push(p >> i);
    d[p] = mapping(f, d[p]);
    for (int i = 1; i <= log; i++)
      update(p >> i);
  }
  void apply(int l, int r, F f) {
    assert(0 <= l && l <= r && r <= _n);
    if (l == r)
      return;
    l += size;
    r += size;
    for (int i = log; i >= 1; i--) {
      if (((l >> i) << i) != l)
        push(l >> i);
      if (((r >> i) << i) != r)
        push((r - 1) >> i);
    }
    {
      int l2 = l, r2 = r;
      while (l < r) {
        if (l & 1)
          all_apply(l++, f);
        if (r & 1)
          all_apply(--r, f);
        l >>= 1;
        r >>= 1;
      }
      l = l2;
      r = r2;
    }
    for (int i = 1; i <= log; i++) {
      if (((l >> i) << i) != l)
        update(l >> i);
      if (((r >> i) << i) != r)
        update((r - 1) >> i);
    }
  }
  template <bool (*g)(S)> int max_right(int l) {
    return max_right(l, [](S x) { return g(x); });
  }
  template <class G> int max_right(int l, G g) {
    assert(0 <= l && l <= _n);
    assert(g(e()));
    if (l == _n)
      return _n;
    l += size;
    for (int i = log; i >= 1; i--)
      push(l >> i);
    S sm = e();
    do {
      while (l % 2 == 0)
        l >>= 1;
      if (!g(op(sm, d[l]))) {
        while (l < size) {
          push(l);
          l = (2 * l);
          if (g(op(sm, d[l]))) {
            sm = op(sm, d[l]);
            l++;
          }
        }
        return l - size;
      }
      sm = op(sm, d[l]);
      l++;
    } while ((l & -l) != l);
    return _n;
  }
  template <bool (*g)(S)> int min_left(int r) {
    return min_left(r, [](S x) { return g(x); });
  }
  template <class G> int min_left(int r, G g) {
    assert(0 <= r && r <= _n);
    assert(g(e()));
    if (r == 0)
      return 0;
    r += size;
    for (int i = log; i >= 1; i--)
      push((r - 1) >> i);
    S sm = e();
    do {
      r--;
      while (r > 1 && (r % 2))
        r >>= 1;
      if (!g(op(d[r], sm))) {
        while (r < size) {
          push(r);
          r = (2 * r + 1);
          if (g(op(d[r], sm))) {
            sm = op(d[r], sm);
            r--;
          }
        }
        return r + 1 - size;
      }
      sm = op(d[r], sm);
    } while ((r & -r) != r);
    return 0;
  }

private:
  int _n, size, log;
  std::vector<S> d;
  std::vector<F> lz;
  void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
  void all_apply(int k, F f) {
    d[k] = mapping(f, d[k]);
    if (k < size)
      lz[k] = composition(f, lz[k]);
  }
  void push(int k) {
    all_apply(2 * k, lz[k]);
    all_apply(2 * k + 1, lz[k]);
    lz[k] = id();
  }
};

constexpr int MOD = 998244353;
int n;

// モノイド(S,op,e)
struct S {
  mint<MOD> val;
  int left, right;
};
// 作用素
struct F {
  int a;
};
// S×S->S
S op(S l, S r) {
  return S{l.val + r.val, min(l.left, r.left), max(l.right, r.right)};
}
// 単位元
S e() { return S{0, 1000000000, 0}; }
// f(s)
// f(op(x,y)) = op(f(x),f(y))を満たす必要がある
S mapping(F f, S s) {
  if (f.a == -1)
    return s;
  // cout << f.a << " " << s.val << " " << s.left << " " << s.right << endl;
  return S{mint<MOD>(10).pow(n - s.right) *
               (mint<MOD>(10).pow(s.right - s.left) - 1) / 9 * f.a,
           s.left, s.right};
}
// f(g(x))となるF
F composition(F f, F g) { return f.a != -1 ? F{f.a} : F{g.a}; }
// id(x)=xとなるF
F id() { return F{-1}; }

int main() {
  int q;
  cin >> n >> q;
  vector<S> a(n);
  for (int i = 0; i < n; i++) {
    a[i].val = mint<MOD>(10).pow(n - i - 1);
    a[i].left = i;
    a[i].right = i + 1;
  }
  lazy_segtree<S, op, e, F, mapping, composition, id> seg(a);
  for (int i = 0; i < q; i++) {
    int l, r, d;
    cin >> l >> r >> d;
    seg.apply(l - 1, r, F{d});
    cout << seg.prod(0, n).val << endl;
  }
  return 0;
}

/////////////////////////////////////////