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: Wrong Answer)

#![allow(unused)]

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

// struct Delta {
//     value: Modulo,
//     mask: usize,
// }
//
// impl Default for Delta {
//     fn default() -> Self {
//         Self {
//             value: Modulo::new(1),
//             mask: 0,
//         }
//     }
// }
//
// impl Delta {
//     fn new(value: Modulo, mask: usize) -> Self {
//         Self { value, mask }
//     }
// }
//
// impl std::ops::Add for Delta {
//     type Output = Self;
//
//     fn add(self, rhs: Self) -> Self::Output {
//         let value = self.value * rhs.value;
//         let mask = self.mask | rhs.mask;
//         Self { value, mask }
//     }
// }
//
// #[derive(Default, Copy, Clone)]
// struct Node {
//     value: Modulo,
//     mask: usize,
//     size: usize,
// }
//
// impl Node {
//     fn new(value: Modulo) -> Self {
//         Self {
//             value,
//             mask: 0,
//             size: 1,
//         }
//     }
//     fn new_by_child(l: Self, r: Self) -> Self {
//         Self {
//             value: l.value + r.value,
//             mask: l.mask | r.mask,
//             size: l.size + r.size,
//         }
//     }
// }

use proconio::marker::Usize1;

struct LazySegTree<Node, Delta, NodeMerge, ApplyDelta, UpdateDelta> {
    n: usize,
    tree_height: usize,
    tree: Vec<Node>,
    lazy_delta: Vec<Delta>,
    node_init: Node,
    delta_init: Delta,
    node_merge: NodeMerge,
    apply_delta: ApplyDelta,
    update_delta: UpdateDelta,
    dirty: Vec<bool>,
}

impl<Node, Delta, NodeMerge, ApplyDelta, UpdateDelta>
    LazySegTree<Node, Delta, NodeMerge, ApplyDelta, UpdateDelta>
where
    Node: Copy,
    Delta: Copy,
    NodeMerge: Fn(Node, Node) -> Node,
    ApplyDelta: Fn(Node, Delta) -> Node,
    UpdateDelta: Fn(Delta, Delta) -> Delta,
{
    fn new(
        n: usize,
        node_init: Node,
        delta_init: Delta,
        node_merge: NodeMerge,
        apply_delta: ApplyDelta,
        update_delta: UpdateDelta,
    ) -> Self {
        let mut tree_height = 0;
        while (1 << tree_height) < n {
            tree_height += 1;
        }
        let mut tree = vec![node_init; n * 2];
        for i in 0..n {
            tree[i + n] = node_init;
        }
        for i in (1..n).rev() {
            tree[i] = (node_merge)(tree[i * 2], tree[i * 2 + 1]);
        }

        Self {
            n,
            tree_height,
            tree,
            lazy_delta: vec![delta_init; n],
            node_init,
            delta_init,
            node_merge,
            apply_delta,
            update_delta,
            dirty: vec![false; n],
        }
    }

    // 1. update Delta for Node
    // 2. Delta accumulate
    fn apply(&mut self, i: usize, delta: Delta) {
        self.tree[i] = (self.apply_delta)(self.tree[i], delta);
        if i < self.n {
            self.lazy_delta[i] = (self.update_delta)(self.lazy_delta[i], delta);
            self.dirty[i] = true;
        }
    }

    fn query(&mut self, l: usize, r: usize) -> Node {
        if l >= r {
            return self.node_init;
        }
        let mut l = l + self.n;
        let mut r = r + self.n;
        self.propagate(l);
        self.propagate(r - 1);
        let mut lp = self.node_init;
        let mut rp = self.node_init;
        while l < r {
            if l & 1 == 1 {
                lp = (self.node_merge)(lp, self.tree[l]);
                l += 1;
            }
            if r & 1 == 1 {
                r -= 1;
                rp = (self.node_merge)(self.tree[r], rp);
            }
            l /= 2;
            r /= 2;
        }
        (self.node_merge)(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] = (self.node_merge)(self.tree[i * 2], self.tree[i * 2 + 1]);
            if self.dirty[i] {
                self.tree[i] = (self.apply_delta)(self.tree[i], 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] {
                println!("p: {}", i);
                self.apply(i * 2, self.lazy_delta[i]);
                self.apply(i * 2 + 1, self.lazy_delta[i]);
                self.lazy_delta[i] = self.delta_init;
                self.dirty[i] = false;
            }
        }
    }
}

fn main() {
    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 f = std::cmp::max;
    let g = |a: i64, b: i64| a + b;
    let h = |a: i64, b: i64| a + b;

    let mut tree = LazySegTree::new(n, 0, 0, f, g, h);

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

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