Problem:
Score : 100 points

Problem Statement

Consider a string of length N consisting of 0 and 1.
The score for the string is calculated as follows:

For each i (1 \leq i \leq M), a_i is added to the score if the string contains 1 at least once between the l_i-th and r_i-th characters (inclusive).

Find the maximum possible score of a string.

Constraints

All values in input are integers.

1 \leq N \leq 2 × 10^5

1 \leq M \leq 2 × 10^5

1 \leq l_i \leq r_i \leq N

|a_i| \leq 10^9

Input

Input is given from Standard Input in the following format:

N M
l_1 r_1 a_1
l_2 r_2 a_2
:
l_M r_M a_M

Output

Print the maximum possible score of a string.

Sample Input 1

5 3
1 3 10
2 4 -10
3 5 10

Sample Output 1

20

The score for 10001 is a_1 + a_3 = 10 + 10 = 20.

Sample Input 2

3 4
1 3 100
1 1 -10
2 2 -20
3 3 -30

Sample Output 2

90

The score for 100 is a_1 + a_2 = 100 + (-10) = 90.

Sample Input 3

1 1
1 1 -10

Sample Output 3

0

The score for 0 is 0.

Sample Input 4

1 5
1 1 1000000000
1 1 1000000000
1 1 1000000000
1 1 1000000000
1 1 1000000000

Sample Output 4

5000000000

The answer may not fit into a 32-bit integer type.

Sample Input 5

6 8
5 5 3
1 1 10
1 6 -8
3 6 5
3 4 9
5 5 -2
1 3 -6
4 6 -7

Sample Output 5

10

For example, the score for 101000 is a_2 + a_3 + a_4 + a_5 + a_7 = 10 + (-8) + 5 + 9 + (-6) = 10.

Solution in Rust (1.42.0) (judge verdict: Accepted)

#![allow(unused)]

// ///////////////
// Lazy SegTree //
// ///////////////

use std::ops::Add;

#[derive(Copy, Clone)]
struct Delta {
    value: i64,
}
impl Default for Delta {
    fn default() -> Self {
        Self { value: 0 }
    }
}
impl Delta {
    fn new(value: i64) -> Self {
        Self { value }
    }
    fn update_delta(&mut self, delta: Delta) {
        self.value += delta.value;
    }
}

#[derive(Copy, Clone)]
struct Node {
    value: i64,
}
impl Node {
    fn new(value: i64) -> Self {
        Self { value }
    }
    fn new_from_child(lhs: Self, rhs: Self) -> Self {
        Self {
            value: std::cmp::max(lhs.value, rhs.value),
        }
    }
    fn apply_delta(&mut self, delta: Delta) {
        self.value += delta.value;
    }
}

impl Default for Node {
    fn default() -> Self {
        Self { value: 0 }
    }
}

struct LazySegTree {
    n: usize,
    tree_height: usize,
    tree: Vec<Node>,
    lazy_delta: Vec<Delta>,
    dirty: Vec<bool>,
}

impl LazySegTree {
    fn new(n: usize) -> Self {
        let nodes = vec![Node::default(); n];
        LazySegTree::new_from_base(n, nodes)
    }

    fn new_from_base(n: usize, nodes: Vec<Node>) -> Self {
        assert_eq!(nodes.len(), n);
        let mut tree_height = 0;
        while (1 << tree_height) < n {
            tree_height += 1;
        }
        let mut tree = vec![Node::default(); n * 2];
        for i in 0..n {
            tree[i] = nodes[i];
        }
        for i in (1..n).rev() {
            tree[i] = Node::new_from_child(tree[i * 2], tree[i * 2 + 1]);
        }

        Self {
            n,
            tree_height,
            tree,
            lazy_delta: vec![Delta::default(); n],
            dirty: vec![false; n],
        }
    }

    // 1. update Delta for Node
    // 2. Delta accumulate
    fn apply(&mut self, i: usize, delta: Delta) {
        self.tree[i].apply_delta(delta);

        if i < self.n {
            self.lazy_delta[i].update_delta(delta);
            self.dirty[i] = true;
        }
    }

    fn query(&mut self, l: usize, r: usize) -> Node {
        if l >= r {
            return Node::default();
        }
        let mut l = l + self.n;
        let mut r = r + self.n;
        self.propagate(l);
        self.propagate(r - 1);
        let mut lp = Node::default();
        let mut rp = Node::default();
        while l < r {
            if l & 1 == 1 {
                lp = Node::new_from_child(lp, self.tree[l]);
                l += 1;
            }
            if r & 1 == 1 {
                r -= 1;
                rp = Node::new_from_child(self.tree[r], rp);
            }
            l /= 2;
            r /= 2;
        }
        Node::new_from_child(lp, rp)
    }

    fn update(&mut self, l: usize, r: usize, delta: Delta) {
        if l >= r {
            return;
        }

        let mut l = l + self.n;
        let mut r = r + self.n;

        self.propagate(l);
        self.propagate(r - 1);
        let origin_l = l.clone();
        let origin_r = r.clone();

        while l < r {
            if l & 1 == 1 {
                self.apply(l, delta);
                l += 1;
            }
            if r & 1 == 1 {
                r -= 1;

                self.apply(r, delta);
            }
            l /= 2;
            r /= 2;
        }
        self.build(origin_l);
        self.build(origin_r - 1);
    }

    fn build(&mut self, node: usize) {
        let mut i = node / 2;
        while i > 0 {
            self.tree[i] = Node::new_from_child(self.tree[i * 2], self.tree[i * 2 + 1]);
            if self.dirty[i] {
                self.tree[i].apply_delta(self.lazy_delta[i]);
            }
            i /= 2;
        }
    }

    fn propagate(&mut self, node: usize) {
        for h in (1..=self.tree_height).rev() {
            let i = node >> h;
            if self.dirty[i] {
                self.apply(i * 2, self.lazy_delta[i]);
                self.apply(i * 2 + 1, self.lazy_delta[i]);
                self.lazy_delta[i] = Delta::default();
                self.dirty[i] = false;
            }
        }
    }
}

fn main() {
    use proconio::marker::Usize1;
    use proconio::*;

    input! {
    n: usize,
    m: usize,
    a: [(Usize1, Usize1, i64); m]
    }
    let mut q = vec![vec![]; n];
    for (l, r, a) in a {
        q[r].push((l, a));
    }
    let mut tree = LazySegTree::new(n);

    for r in 0..n {
        let node = tree.query(0, r);
        tree.update(r, r + 1, Delta::new(node.value));

        for &(l, a) in &q[r] {
            tree.update(l, r + 1, Delta::new(a));
        }
    }
    let ans = tree.query(0, n);
    println!("{:?}", ans.value);
}