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 <bits/stdc++.h>
#define fi first
#define se second
using namespace std;
using ll = long long;

constexpr int N = 200009;
int n, m; 
ll x[N], dp[N], s[N << 2], lazy[N << 2];
vector<int> ending[N];
vector<pair<pair<int, int>, int>> seg;

inline int L(int v) {return v << 1;}
inline int R(int v) {return L(v) + 1;}

void build(int v, int l, int r) {
    if(l == r) {
        s[v] = x[l];
    } else {
        int m = l + r >> 1;
        build(L(v), l, m);
        build(R(v), m + 1, r);
        s[v] = max(s[L(v)], s[R(v)]);
    }
}
void push(int v) {
    if(!lazy[v]) return;
    lazy[L(v)] += lazy[v];
    s[L(v)] += lazy[v];
    lazy[R(v)] += lazy[v];
    s[R(v)] += lazy[v];
    lazy[v] = 0;
}
ll mx(int v, int l, int r, int ql, int qr) {
    if(l > qr || r < ql) return 0;
    if(ql <= l && r <= qr) return s[v];
    push(v);
    int m = l + r >> 1;
    return max(mx(L(v), l, m, ql, qr), mx(R(v), m + 1, r, ql, qr));
}
void add(int v, int l, int r, int ql, int qr, ll value) {
    if(l > qr || r < ql) return;
    if(ql <= l && r <= qr) {
        lazy[v] += value;
        s[v] += value;
    } else {
        push(v);
        int m = l + r >> 1;
        add(L(v), l, m, ql, qr, value);
        add(R(v), m + 1, r, ql, qr, value);
        s[v] = max(s[L(v)], s[R(v)]);
    }
}
int main() {
    ios::sync_with_stdio(0); cin.tie(0);
    cin >> n >> m;
    for(int i = 0; i < m; ++i) {
        int l, r, a;
        cin >> l >> r >> a;
        x[l] += a;
        x[r + 1] -= a;
        seg.push_back({{l, r}, a});
        ending[r].push_back(i);
    }

    for(int i = 1; i < N; ++i) {
        x[i] += x[i - 1];
    }
    for(int i = 1; i < N; ++i) {
        x[i] = -x[i];
    }
    build(1, 1, n);
    for(int i = 1; i <= n; ++i) {
        dp[i] = -x[i];
        for(int j : ending[i - 1]) {
            add(1, 1, n, seg[j].fi.fi, seg[j].fi.se, seg[j].se);
        }
        dp[i] += mx(1, 1, n, 1, i - 1);
        add(1, 1, n, i, i, dp[i]);
    }
    cout << max(0LL, *max_element(dp + 1, dp + n + 1)) << '\n';   
}