#include // Interval represents [left, right) with value. struct Interval { int64_t left, right, value; bool Contains(int64_t x) const { return left <= x && x < right; } bool operator<(const Interval& i) const { return left < i.left; }; }; std::ostream& operator<<(std::ostream& os, const Interval& i) { os << "[" << i.left << "," << i.right << ")"; if (i.value != 0) os << "=" << i.value; return os; } class Intervals : public std::set { public: // Inserts an interval [left, right) with vlaue. If it would result in // consecutive intervals with the same value, they are concatenated. // // NOTE: The new interval must not overlap with any existing intervals. Call // Erase first to ensure that if necessary. void Insert(int64_t left, int64_t right, int64_t value = 0) { auto it = LowerBound(left); if (it != begin()) { auto pit = prev(it); assert(pit->right <= left); // Assert no overlap on the left. if (pit->right == left && pit->value == value) { left = pit->left; erase(pit); } } if (it != end()) { assert(right <= it->left); // Assert no overlap on the right. if (right == it->left && value == it->value) { right = it->right; erase(it); } } insert({left, right, value}); } // Erases intervals that overlap with [left, right). Partial overlaps are // erased partially. Returns erased intervals. std::vector Erase(int64_t left, int64_t right) { auto it = LowerBound(left), jt = it; while (jt != end() && jt->left < right) ++jt; std::vector erased(it, jt); erase(it, jt); if (!erased.empty()) { if (auto& i = erased[0]; i.left < left) { insert({i.left, left, i.value}); i.left = left; } if (auto& i = erased.back(); right < i.right) { insert({right, i.right, i.value}); i.right = right; } } return erased; } // Returns the first interval that either contains x or is on the right of x. std::set::iterator LowerBound(int64_t x) const { auto it = lower_bound({x, 0, 0}); if (it != begin() && x < prev(it)->right) --it; return it; } // Returns an interval containing x if exists. std::optional Find(int64_t x) const { auto it = LowerBound(x); if (it != end() && it->Contains(x)) return *it; return std::nullopt; } // Returns mex[left, infinity). int64_t Mex(int64_t left) const { auto i = Find(left); return i ? i->right : left; } }; #include template struct is_dereferenceable : std::false_type {}; template struct is_dereferenceable())>> : std::true_type {}; template struct is_iterable : std::false_type {}; template struct is_iterable())), decltype(std::end(std::declval()))>> : std::true_type {}; template struct is_applicable : std::false_type {}; template struct is_applicable::value)>> : std::true_type {}; template void debug(const T& value, const Ts&... args); template void debug(const T& v) { if constexpr (is_dereferenceable::value) { std::cerr << "{"; if (v) { debug(*v); } else { std::cerr << "nil"; } std::cerr << "}"; } else if constexpr (is_iterable::value && !std::is_same::value) { std::cerr << "{"; for (auto it = std::begin(v); it != std::end(v); ++it) { if (it != std::begin(v)) std::cerr << ", "; debug(*it); } std::cerr << "}"; } else if constexpr (is_applicable::value) { std::cerr << "{"; std::apply([](const auto&... args) { debug(args...); }, v); std::cerr << "}"; } else { std::cerr << v; } } template void debug(const T& value, const Ts&... args) { debug(value); std::cerr << ", "; debug(args...); } #if DEBUG #define dbg(...) \ do { \ cerr << #__VA_ARGS__ << ": "; \ debug(__VA_ARGS__); \ cerr << " (L" << __LINE__ << ")\n"; \ } while (0) #else #define dbg(...) #endif void read_from_cin() {} template void read_from_cin(T& value, Ts&... args) { std::cin >> value; read_from_cin(args...); } #define rd(type, ...) \ type __VA_ARGS__; \ read_from_cin(__VA_ARGS__); #define ints(...) rd(int, __VA_ARGS__); #define strings(...) rd(string, __VA_ARGS__); // Strings used for yes/no questions. Defined as variables so that it can be // adjusted for each contest site. const char *yes_str = "Yes", *no_str = "No"; template void write_to_cout(const T& value) { if constexpr (std::is_same::value) { std::cout << (value ? yes_str : no_str); } else if constexpr (is_iterable::value && !std::is_same::value) { for (auto it = std::begin(value); it != std::end(value); ++it) { if (it != std::begin(value)) std::cout << " "; std::cout << *it; } } else { std::cout << value; } } template void write_to_cout(const T& value, const Ts&... args) { write_to_cout(value); std::cout << ' '; write_to_cout(args...); } #define wt(...) \ do { \ write_to_cout(__VA_ARGS__); \ cout << '\n'; \ } while (0) #define all(x) (x).begin(), (x).end() #define eb(...) emplace_back(__VA_ARGS__) #define pb(...) push_back(__VA_ARGS__) #define dispatch(_1, _2, _3, name, ...) name #define as_i64(x) \ ( \ [] { \ static_assert( \ std::is_integral< \ typename std::remove_reference::type>::value, \ "rep macro supports std integral types only"); \ }, \ static_cast(x)) #define rep3(i, a, b) for (int64_t i = as_i64(a); i < as_i64(b); ++i) #define rep2(i, n) rep3(i, 0, n) #define rep1(n) rep2(_loop_variable_, n) #define rep(...) dispatch(__VA_ARGS__, rep3, rep2, rep1)(__VA_ARGS__) #define rrep3(i, a, b) for (int64_t i = as_i64(b) - 1; i >= as_i64(a); --i) #define rrep2(i, n) rrep3(i, 0, n) #define rrep1(n) rrep2(_loop_variable_, n) #define rrep(...) dispatch(__VA_ARGS__, rrep3, rrep2, rrep1)(__VA_ARGS__) #define each3(k, v, c) for (auto&& [k, v] : c) #define each2(e, c) for (auto&& e : c) #define each(...) dispatch(__VA_ARGS__, each3, each2)(__VA_ARGS__) template std::istream& operator>>(std::istream& is, std::vector& v) { for (T& vi : v) is >> vi; return is; } template std::istream& operator>>(std::istream& is, std::pair& p) { is >> p.first >> p.second; return is; } template bool chmax(T& a, U b) { if (a < b) { a = b; return true; } return false; } template bool chmin(T& a, U b) { if (a > b) { a = b; return true; } return false; } template auto max(T a, U b) { return a > b ? a : b; } template auto min(T a, U b) { return a < b ? a : b; } template int64_t sz(const T& v) { return std::size(v); } template int64_t popcount(T i) { return std::bitset::digits>(i).count(); } template bool hasbit(T s, int i) { return std::bitset::digits>(s)[i]; } template auto div_floor(T n, U d) { if (d < 0) { n = -n; d = -d; } if (n < 0) { return -((-n + d - 1) / d); } return n / d; }; template auto div_ceil(T n, U d) { if (d < 0) { n = -n; d = -d; } if (n < 0) { return -(-n / d); } return (n + d - 1) / d; } template bool even(T x) { return x % 2 == 0; } std::array, 4> adjacent(int64_t i, int64_t j) { return {{{i + 1, j}, {i, j + 1}, {i - 1, j}, {i, j - 1}}}; } bool inside(int64_t i, int64_t j, int64_t I, int64_t J) { return 0 <= i && i < I && 0 <= j && j < J; } constexpr int64_t int_pow(int64_t b, int64_t e) { int64_t x = 1; for (int64_t i = 0; i < e; ++i) { x *= b; } return x; } // big = 2305843009213693951 = 2^61-1 ~= 2.3*10^18 const int64_t big = std::numeric_limits::max() / 4; using i64 = int64_t; using i32 = int32_t; template using low_priority_queue = std::priority_queue, std::greater>; template using V = std::vector; template using VV = V>; void Main(); int main() { std::ios_base::sync_with_stdio(false); std::cin.tie(NULL); std::cout << std::fixed << std::setprecision(20); Main(); return 0; } const auto& Fix = boost::hana::fix; using namespace std; #define int i64 void Main() { ints(d, q); Intervals is; int ans = -big; rep(q) { ints(a, b); --a; is.Erase(a, b); is.Insert(a, b); auto i = is.Find(a); chmax(ans, i->right - i->left); wt(ans); } }