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.15.1) (judge verdict: Accepted)

use std::cmp::max;
use std::collections::HashMap;
use std::error::Error;
use std::io;

fn main() {
    if let Err(_e) = run() {
        panic!("failed.");
    };
}

// Max value segment tree.
#[derive(Debug)]
struct SegTree {
    n: usize,
    cached: Vec<i64>,
    values: Vec<i64>,
}

impl SegTree {
    pub fn new(size: i64) -> SegTree {
        let mut n = 1;
        while size + 1 > n {
            n = n * 2;
        }
        SegTree {
            n: n as usize,
            cached: vec![0; n as usize * 2 - 1],
            values: vec![0; n as usize * 2 - 1],
        }
    }

    // (a, b]
    fn add(&mut self, a: usize, b: usize, value: i64) {
        let n = self.n;
        self.add_internal(0, 0, n, a, b, value);
    }
    fn add_internal(&mut self, index: usize, l: usize, r: usize, a: usize, b: usize, value: i64) {
        // println!("{} {} {} {}:{} -> {}", l, r, a, b, index, value);
        if l >= b || r <= a {
            // We always do both side recursively, so it may out of range.
            return;
        }
        if a <= l && r <= b {
            //in the range
            self.cached[index] += value;
            self.values[index] += value;
        } else {
            self.add_internal(index * 2 + 1, l, (l + r) / 2, a, b, value);
            self.add_internal(index * 2 + 2, (l + r) / 2, r, a, b, value);
            self.values[index] =
                self.cached[index] + max(self.values[index * 2 + 1], (self.values[index * 2 + 2]));
        }
    }

    // find max
    fn get(&self, a: usize, b: usize) -> i64 {
        return self.get_internal(0, 0, self.n, a, b);
    }

    fn get_internal(&self, index: usize, l: usize, r: usize, a: usize, b: usize) -> i64 {
        if r <= a || l >= b {
            return std::i64::MIN;
        }
        if a <= l && r <= b {
            return self.values[index];
        }

        return self.cached[index]
            + max(
                self.get_internal(index * 2 + 1, l, (l + r) / 2, a, b),
                self.get_internal(index * 2 + 2, (l + r) / 2, r, a, b),
            );
    }

    fn leaf_count(&self) -> usize {
        (self.values.len() + 1) / 2
    }
}

fn run() -> Result<(), Box<Error>> {
    let mut input = String::new();
    io::stdin().read_line(&mut input);
    let n_m: Vec<i64> = input
        .trim()
        .split_whitespace()
        .map(|s| s.parse::<i64>().unwrap())
        .collect();
    let n = n_m[0];
    let m = n_m[1];
    input.clear();
    let mut adds = HashMap::new();
    let mut removes = HashMap::new();
    for i in 0..m {
        let mut input = String::new();
        io::stdin().read_line(&mut input);
        let lra: Vec<i64> = input
            .trim()
            .split_whitespace()
            .map(|s| s.parse::<i64>().unwrap())
            .collect();
        let values = adds.entry(lra[0]).or_insert(0);
        *values += lra[2];
        let remove_values = removes.entry(lra[1]).or_insert_with(Vec::new);
        remove_values.push((lra[0], lra[2]));
        input.clear();
    }
    let mut tree = SegTree::new(n);
    let mut result = 0;
    for i in 1..n + 1 {
        for &add_values in adds.get(&i) {
            tree.add(0, i as usize, add_values);
        }
        let tmp_max = tree.get(0, i as usize);
        result = max(result, tmp_max);
        tree.add(i as usize, (i + 1) as usize, tmp_max);
        // println!(">>>>after add {:?} = {:?}", i, tree);
        for remove_values in removes.get(&i) {
            for &(l, a) in remove_values {
                tree.add(0, l as usize, -a);
                // println!(">>>>after remove {} from {} = {:?}", a, l, tree);
            }
        }
    }
    println!("{}", result);
    Ok(())
}