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 <iostream>
#include <cstdint>
#include <algorithm>
#include <utility>
#include <vector>

int const MAXN = 200000;
int const MAXM = 200000;
uint64_t const INF = 1<<59;

int const MAXA = (1<<19)-1;

int N, M, NN;

int64_t dp[MAXA], lazy[MAXA];
std::vector<std::pair<int, int> > scores[MAXM];

void init() {
  NN=1;
  while(NN<N+2) NN<<=1;
  std::fill(dp, dp+NN*2-1, 0);
  std::fill(lazy, lazy+NN*2-1, 0);
}

void eval(int k) {
  if(lazy[k] == 0) return;
  if(k*2+1 < NN*2-1) {
    lazy[2*k+1] += lazy[k];
    lazy[2*k+2] += lazy[k];
  }
  dp[k] += lazy[k];
  lazy[k] = 0;
}

int64_t update(int a, int b, int64_t x, int k, int l, int r) {
  if(b <= l || r <= a) {
    eval(k);
    return dp[k];
  }
  if(a <= l && r <= b) {
    lazy[k] += x;
    return dp[k] + lazy[k];
  }
  eval(k);
  int m = (l+r)/2;
  return dp[k] = std::max(update(a, b, x, k*2+1, l, m), update(a, b, x, k*2+2, m, r));
}

int64_t query(int a, int b, int k, int l, int r) {
  if(b <= l || r <= a) return -INF;
  eval(k);
  if(a <= l && r <= b) return dp[k];
  int m = (l+r)/2;
  bool intLeft = !(m <= a || b <= l);
  bool intRight = !(r <= a || b <= m);
  if(intLeft&intRight) return std::max(query(a, b, k*2+1, l, m), query(a, b, k*2+2, m, r));
  if(intLeft) return query(a, b, k*2+1, l, m);
  return query(a, b, k*2+2, m, r);
}

void add(int a, int b, int64_t x) { update(a, b, x, 0, 0, NN); }
int64_t get_max(int a, int b) { return query(a, b, 0, 0, NN); }

int main() {
  std::cin >> N >> M;
  for(int i = 0; i < M; ++i) {
    int l, r, a;
    std::cin >> l >> r >> a; --l; --r;
    scores[r].emplace_back(l, a);
  }

  init();
  for(int i = 0; i < N; ++i) {
    int64_t m = 0;
    if(i > 0) m = std::max(m, get_max(0, i));
    add(i, i+1, m);
    for(auto p: scores[i]) add(p.first, i+1, p.second);
  }
  int64_t m = 0;
  std::cout << std::max(get_max(0, N+1), m) << std::endl;
  return 0;
}