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

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MOD=1e9+7;
const int INF=1e9;
const ll LINF=(ll)1e18;

struct LazySegmentTree{
private:
    int n;
    vector<ll> node,assign,add;
public:
    LazySegmentTree(int sz){
        n=1;
        while(n<sz)n*=2;
        node.resize(2*n-1);
        assign.resize(2*n-1);
        add.resize(2*n-1);
    }
    void eval(int k,int l,int r){
        if(assign[k]!=0){
            node[k]=assign[k];
            if(r-l>1){
                assign[2*k+1]=assign[2*k+2]=assign[k];
                add[2*k+1]=add[2*k+2]=0;
            }
            assign[k]=0;
        }
        if(add[k]!=0){
            node[k]+=add[k];
            if(r-l>1){
                if(assign[2*k+1]!=0){
                    assign[2*k+1]+=add[k];
                }
                else{
                    add[2*k+1]+=add[k];
                }
                if(assign[2*k+2]!=0){
                    assign[2*k+2]+=add[k];
                }
                else{
                    add[2*k+2]+=add[k];
                }
            }
            add[k]=0;
        }
    }
    void update(int a,int b,int q,ll x,int k=0,int l=0,int r=-1){
        if(r==-1)r=n;
        eval(k,l,r);
        if(b<=l||r<=a)return;
        if(a<=l&&r<=b){
            if(q==0){
                assign[k]=x;
            }
            else{
                add[k]=x;
            }
            eval(k,l,r);
        }
        else{
            update(a,b,q,x,2*k+1,l,(l+r)/2);
            update(a,b,q,x,2*k+2,(l+r)/2,r);
            node[k]=max(node[2*k+1],node[2*k+2]);
        }
    }
    ll get(int a,int b,int k=0,int l=0,int r=-1){
        if(r==-1)r=n;
        eval(k,l,r);
        if(b<=l||r<=a)return 0;
        if(a<=l&&r<=b){
            return node[k];
        }
        else{
            return max(get(a,b,2*k+1,l,(l+r)/2),get(a,b,2*k+2,(l+r)/2,r));
        }
    }
};

int main(){
    int n,m;
    cin>>n>>m;
    pair<int,pair<int,ll>> p[m];
    for(int i=0;i<m;i++){
        int l,r,a;
        cin>>l>>r>>a;
        p[i]={r,{l-1,a}};
    }
    sort(p,p+m);
    LazySegmentTree dp(n);
    for(int i=0;i<m;i++){
        int l=p[i].second.first;
        int r=p[i].first;
        ll a=p[i].second.second;
        dp.update(l,r,1,a);
        ll mx=max(dp.get(0,r),0LL);
        if(r!=n)dp.update(r,n,0,mx);
    }
    cout<<max(dp.get(0,n),0LL)<<endl;
}