Language: C++

#pragma region include
#include <iostream>
#include <iomanip>
#include <stdio.h>
#include <vector>
#include <algorithm>
#include <cmath>
#include <map>
#include <set>
#include <string>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <limits>
#include <list>
#include <numeric>
#include <queue>
#include <stack>
#include <utility>
#include <array>
#include <random>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <assert.h>
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;
    }
};

#include <atcoder/lazysegtree>

// 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;
    }
    atcoder::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;
}

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

Compiler output:
a.cc:156:10: fatal error: atcoder/lazysegtree: No such file or directory
  156 | #include <atcoder/lazysegtree>
      |          ^~~~~~~~~~~~~~~~~~~~~
compilation terminated.