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

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 {
    array: Vec<i64>,
}

impl SegTree {
    // (a, b]
    fn add(&mut self, a: usize, b: usize, value: i64) {
        let leaf_count = self.leaf_count();
        self.add_internal(0, 0, leaf_count, a, b, value);
    }
    fn add_internal(
        &mut self,
        index: usize,
        l: usize,
        r: usize,
        a: usize,
        b: usize,
        value: i64,
    ) -> i64 {
        // println!("{} {} {} {}:{} -> {}", l, r, a, b, index, value);
        if a <= l && b >= r && l + 1 == r {
            // leaf node
            self.array[index] += value;
            return self.array[index];
        }
        let middle = (l + r) / 2;
        let mut result = 0;
        if a < middle {
            result = max(
                result,
                self.add_internal(index * 2 + 1, l, middle, a, b, value),
            );
        }
        if b > middle {
            result = max(
                result,
                self.add_internal(index * 2 + 2, middle, r, a, b, value),
            );
        }
        self.array[index] = result;
        self.array[index]
    }

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

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

        let middle = (l + r) / 2;
        let mut result = 0;
        if a < middle {
            result = max(result, self.get_internal(index * 2 + 1, l, middle, a, b));
        }
        if b > middle {
            result = max(result, self.get_internal(index * 2 + 2, middle, r, a, b));
        }
        result
    }

    fn leaf_count(&self) -> usize {
        (self.array.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 count = 1;
    while count <= n {
        count *= 2;
    }

    let mut tree = SegTree {
        array: vec![0; (2 * count) as usize],
    };
    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);
            // println!(">>>>after add {:?} = {:?}", i, tree);
        }
        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);
        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(())
}