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 Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

import java.util.*;

class Main {

	public static void main(String[] args) throws Exception {
		final Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int m = sc.nextInt();

		PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> Integer.compare(a[1], b[1]));

		SegmentTree sg = new SegmentTree(n);
		int[][] xs = new int[m][3];
		for (int i = 0; i < m; i++) {
			xs[i][0] = sc.nextInt();
			xs[i][1] = sc.nextInt();
			xs[i][2] = sc.nextInt();
		}
		Arrays.sort(xs, (a, b) -> Integer.compare(a[0], b[0]));

		long answer = 0;
		for (int i = 1, p = 0; i <= n; i++) {
			while (p < m && i >= xs[p][0]) {
				pq.offer(xs[p]);
				sg.add(0, xs[p][0], xs[p][2]);
				p++;
			}
			long v = sg.query(0, i);
			sg.add(i, i + 1, v);

			answer = Math.max(answer, v);

			while (!pq.isEmpty() && pq.peek()[1] <= i) {
				int[] u = pq.poll();
				sg.add(0, u[0], -u[2]);
			}
		}

		System.out.println(answer);
	}

	static class SegmentTree {
		private final int n;
		private long[] data;
		private long[] add;

		public SegmentTree(int n) {
			int t = 1;
			while (t < n) t <<= 1;
			this.n = t;
			this.data = new long[t * 2 - 1];
			this.add = new long[t * 2 - 1];
		}

		// [l, r) の最大値
		public long query(int a, int b) {
			return query(a, b, 0, 0, n);
		}

		private long query(int a, int b, int k, int l, int r) {
			if (b <= l || r <= a) return Integer.MIN_VALUE;
			if (a <= l && r <= b) return data[k];
			long vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
			long vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
			return Math.max(vl, vr);
		}

		// [a, b) に v を追加する
		public void add(int a, int b, long v) {
			add(a, b, v, 0, 0, n);
		}

		private void add(int a, int b, long v, int k, int l, int r) {
			if (b <= l || r <= a) return;
			if (a <= l && r <= b) {
				add[k] += v;
				data[k] += v;
				return;
			}

			add(a, b, v, k * 2 + 1, l, (l + r) / 2);
			add(a, b, v, k * 2 + 2, (l + r) / 2, r);
			data[k] = Math.max(data[k * 2 + 1], data[k * 2 + 2]) + add[k];
		}
	}
}