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 C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;

#define fi first
#define se second
#define mp make_pair
#define pb push_back
typedef pair<int, int> ii;
typedef long long ll;

const int len = 2e5+5;
const ll inf = 1e16;
ll tree[4*len], dp[len], lazy[4*len];
vector<ii> vec[len];

void prop(int p, int l, int r){
    if (lazy[p] == 0)
        return;

    tree[p] += lazy[p];
    if (l < r){
        lazy[2*p] += lazy[p];
        lazy[2*p+1] += lazy[p];
    }
    lazy[p] = 0;
}

void update(int p, int l, int r, int i, int j, ll v){
    prop(p, l, r);
    if (r < i || j < l)
        return;
    if (i <= l && r <= j)
        lazy[p] += v;
    else{
        int mid = (l+r)/2;
        update(2*p, l, mid, i, j, v), update(2*p+1, mid+1, r, i, j, v);
        prop(2*p, l, mid), prop(2*p+1, mid+1, r);
        tree[p] = max(tree[2*p], tree[2*p+1]);
    }
}

ll query(int p, int l, int r, int i, int j){
    prop(p, l, r);
    if (r < i || j < l)
        return -inf;
    if (i <= l && r <= j)
        return tree[p];

    int mid = (l+r)/2;
    return max(query(2*p, l, mid, i, j), query(2*p+1, mid+1, r, i, j));
}

int main(){
    int n, m;
    scanf("%d %d", &n, &m);
    for (int i = 0; i < m; i++){
        int l, r, c;
        scanf("%d %d %d", &l, &r, &c);
        vec[l].pb(mp(r, c));
    }

    for (int i = n; i >= 0; i--){
        dp[i] = max(0LL, query(1, 1, n, i+1, n));

        if (i == 0)
            break;

        update(1, 1, n, i, i, dp[i]);
        for (int j = 0; j < vec[i].size(); j++){
            ii v = vec[i][j];
            update(1, 1, n, i, v.fi, v.se);
        }
    }

    printf("%lld\n", dp[0]);
    return 0;
}