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 Go (1.6) (judge verdict: Wrong Answer)

package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
	"strconv"
)

func main() {
	fmt.Printf("%d\n", resolve(parseProblem(os.Stdin)))
}

func parseProblem(r io.Reader) (int, map[int][]query) {
	const (
		initialBufSize = 100000
		maxBufSize     = 1000000
	)
	buf := make([]byte, initialBufSize)

	sc := bufio.NewScanner(r)
	sc.Buffer(buf, maxBufSize)
	sc.Split(bufio.ScanWords) // bufio.ScanLines
	n, m := scanInt(sc), scanInt(sc)
	qs := make(map[int][]query, m)
	for i := 0; i < m; i++ {
		l, r, a := scanInt(sc), scanInt(sc)+1, scanInt(sc)
		qs[r] = append(qs[r], query{l: l, r: r, a: a})
	}
	return n, qs
}

type query struct {
	l, r, a int
}

func resolve(n int, qs map[int][]query) int {
	t := newLazySegTree(n + 2)
	for i := 1; i <= n+1; i++ {
		max := t.max(0, i)
		sum := 0
		for _, v := range qs[i] {
			sum += v.a
		}
		t.add(i, i+1, max+sum-t.max(i, i+1))
		for _, v := range qs[i] {
			t.add(v.l, i, v.a)
		}
	}
	return t.max(0, n+2)
}

type lazySegTree struct {
	n       int
	actions []int
	monoid  []int
}

func newLazySegTree(n int) *lazySegTree {
	size := 1
	for size < n {
		size <<= 1
	}
	return &lazySegTree{
		n:       size,
		actions: make([]int, size*2-1),
		monoid:  make([]int, size*2-1),
	}
}

func (t *lazySegTree) update(idx, v int) {
	cur := idx + t.n - 1
	t.evaluate(cur)
	t.monoid[cur] = v
}

func (t *lazySegTree) add(a, b, v int) {
	t._add(a, b, v, 0, 0, t.n)
}

func (t *lazySegTree) _add(a, b, v, k, l, r int) {
	t.evaluate(k)
	if a <= l && r <= b {
		t.actions[k] += v
		t.evaluate(k)
	} else if a < r && l < b {
		if k < t.n-1 {
			t._add(a, b, v, k*2+1, l, (l+r)>>1)
			t._add(a, b, v, k*2+2, (l+r)>>1, r)
			t.monoid[k] = max(t.monoid[k*2+1], t.monoid[k*2+2])
		}
	}
}

func (t *lazySegTree) max(a, b int) int {
	return t._max(a, b, 0, 0, t.n)
}

func (t *lazySegTree) _max(a, b, k, l, r int) int {
	t.evaluate(k)
	if a <= l && r <= b {
		return t.monoid[k]
	} else if a < r && l < b {
		return max(t._max(a, b, k*2+1, l, (l+r)/2), t._max(a, b, k*2+2, (l+r)/2, r))
	}
	return 0
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func (t *lazySegTree) evaluate(k int) {
	if t.actions[k] == 0 {
		return
	}
	t.monoid[k] += t.actions[k]
	if k < t.n-1 {
		t.actions[(k<<1)+1] = t.actions[k]
		t.actions[(k<<1)+2] = t.actions[k]
	}
	t.actions[k] = 0
}

// snip-scan-funcs
func scanInt(sc *bufio.Scanner) int {
	sc.Scan()
	i, _ := strconv.Atoi(sc.Text())
	return int(i)
}
func scanString(sc *bufio.Scanner) string {
	sc.Scan()
	return sc.Text()
}