package main

import (
	"fmt"
	"sort"
)

func main() {
	arr := []int{3, 1, 4, 5, 7}
	magics := [][]int{{2, 5, 5}, {1, 3, 2}}
	ret := maxSum3(arr, magics)
	fmt.Println(ret)
}

// O(N) + O(M * logM) + O(M * logN) + O(N)
func maxSum3(arr []int, magics [][]int) int {
	n := len(arr)
	st := NewSegmentTree3(n)
	sort.Slice(magics, func(i, j int) bool {
		a := magics[i]
		b := magics[j]
		return a[2] < b[2]
	})
	for _, magic := range magics {
		st.update0(magic[0]+1, magic[1]+1, magic[2], 1, n, 1)
	}
	ans := 0
	query := st.buildSingleQuery(n)
	for i := 0; i < n; i++ {
		ans += getMax(query[i], arr[i])
	}
	return ans
}

// 为方法三特别定制的线段树
// 区间上维持最大值的线段树
// 支持区间值更新
// 为本道题定制了一个方法：
// 假设全是单点查询，请统一返回所有单点的结果(一个结果数组，里面有所有单点记录)
type SegmentTree3 struct {
	max    []int
	change []int
	update []bool
	index  int
}

func NewSegmentTree3(size int) *SegmentTree3 {
	ans := &SegmentTree3{}
	N := size + 1
	ans.max = make([]int, N<<2)
	ans.change = make([]int, N<<2)
	ans.update = make([]bool, N<<2)
	return ans
}

func (this *SegmentTree3) pushUp(rt int) {
	this.max[rt] = getMax(this.max[rt<<1], this.max[rt<<1|1])
}
func getMax(a, b int) int {
	if a > b {
		return a
	} else {
		return b
	}

}

func (this *SegmentTree3) pushDown(rt, ln, rn int) {
	if this.update[rt] {
		this.update[rt<<1] = true
		this.update[rt<<1|1] = true
		this.change[rt<<1] = this.change[rt]
		this.change[rt<<1|1] = this.change[rt]
		this.max[rt<<1] = this.change[rt]
		this.max[rt<<1|1] = this.change[rt]
		this.update[rt] = false
	}
}

func (this *SegmentTree3) update0(L, R, C, l, r, rt int) {
	if L <= l && r <= R {
		this.update[rt] = true
		this.change[rt] = C
		this.max[rt] = C
		return
	}
	mid := (l + r) >> 1
	this.pushDown(rt, mid-l+1, r-mid)
	if L <= mid {
		this.update0(L, R, C, l, mid, rt<<1)
	}
	if R > mid {
		this.update0(L, R, C, mid+1, r, rt<<1|1)
	}
	this.pushUp(rt)
}

func (this *SegmentTree3) buildSingleQuery(n int) []int {
	ans := make([]int, n+1)
	this.process(ans, 1, n, 1)
	return ans
}

func (this *SegmentTree3) process(ans []int, l, r, rt int) {
	if l == r {
		ans[this.index] = this.max[rt]
		this.index++
	} else {
		mid := (l + r) >> 1
		this.pushDown(rt, mid-l+1, r-mid)
		this.process(ans, l, mid, rt<<1)
		this.process(ans, mid+1, r, rt<<1|1)
	}
}