```go
package main

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

type Interval struct {
	l, r int
	p    float64
	id   int
}

var (
	a        []int
	intervals []Interval
	children [][]int
	base_max []int
	log2     []int
	st       [][]int
	SZ       int
	offset   int
	pool     [][]float64
)

func query(l, r int) int {
	if l > r {
		return -2000000000
	}
	j := log2[r-l+1]
	if st[l][j] > st[r-(1<<j)+1][j] {
		return st[l][j]
	}
	return st[r-(1<<j)+1][j]
}

func getArray() []float64 {
	if len(pool) > 0 {
		res := pool[len(pool)-1]
		pool = pool[:len(pool)-1]
		return res
	}
	return make([]float64, SZ)
}

func putArray(arr []float64) {
	pool = append(pool, arr)
}

func dfs(u int) []float64 {
	var res []float64
	if len(children[u]) > 0 {
		res = dfs(children[u][0])
		for i := 1; i < len(children[u]); i++ {
			v := children[u][i]
			fv := dfs(v)
			for j := 0; j < SZ; j++ {
				res[j] *= fv[j]
			}
			putArray(fv)
		}
	} else {
		res = getArray()
		for i := 0; i < SZ; i++ {
			res[i] = 1.0
		}
	}

	bMax := base_max[u]
	if bMax < offset {
		bMax = offset
	}
	bIdx := bMax - offset

	for i := 0; i < bIdx && i < SZ; i++ {
		res[i] = 0.0
	}

	p := intervals[u].p
	for i := SZ - 1; i >= 0; i-- {
		term1 := (1.0 - p) * res[i]
		term2 := 0.0
		if i > 0 {
			term2 = p * res[i-1]
		}
		res[i] = term1 + term2
	}

	return res
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Buffer(make([]byte, 1024*1024*10), 1024*1024*10)
	scanner.Split(bufio.ScanWords)

	readInt := func() int {
		scanner.Scan()
		res := 0
		for _, b := range scanner.Bytes() {
			res = res*10 + int(b-'0')
		}
		return res
	}

	readFloat := func() float64 {
		scanner.Scan()
		res, _ := strconv.ParseFloat(scanner.Text(), 64)
		return res
	}

	if !scanner.Scan() {
		return
	}
	n := 0
	for _, b := range scanner.Bytes() {
		n = n*10 + int(b-'0')
	}
	q := readInt()

	a = make([]int, n+2)
	A_max := -2000000000
	for i := 1; i <= n; i++ {
		a[i] = readInt()
		if a[i] > A_max {
			A_max = a[i]
		}
	}

	offset = A_max - q
	for i := 1; i <= n; i++ {
		if a[i] < offset {
			a[i] = offset
		}
	}
	a[0] = offset
	a[n+1] = offset

	log2 = make([]int, n+2)
	log2[1] = 0
	for i := 2; i < n+2; i++ {
		log2[i] = log2[i/2] + 1
	}
	k := 0
	for (1 << k) <= n+2 {
		k++
	}
	st = make([][]int, n+2)
	for i := range st {
		st[i] = make([]int, k)
		st[i][0] = a[i]
	}
	for j := 1; (1 << j) <= n+2; j++ {
		for i := 0; i+(1<<j) <= n+2; i++ {
			if st[i][j-1] > st[i+(1<<(j-1))][j-1] {
				st[i][j] = st[i][j-1]
			} else {
				st[i][j] = st[i+(1<<(j-1))][j-1]
			}
		}
	}

	intervals = make([]Interval, q+1)
	intervals[0] = Interval{l: 0, r: n + 1, p: 0.0, id: 0}
	for i := 1; i <= q; i++ {
		l := readInt()
		r := readInt()
		p := readFloat()
		intervals[i] = Interval{l: l, r: r, p: p, id: i}
	}

	sort.Slice(intervals, func(i, j int) bool {
		if intervals[i].l != intervals[j].l {
			return intervals[i].l < intervals[j].l
		}
		return intervals[i].r > intervals[j].r
	})

	children = make([][]int, q+1)
	stack := []int{0}
	for i := 1; i <= q; i++ {
		for len(stack) > 0 {
			top := stack[len(stack)-1]
			if intervals[top].r >= intervals[i].r {
				break
			}
			stack = stack[:len(stack)-1]
		}
		top := stack[len(stack)-1]
		children[top] = append(children[top], i)
		stack = append(stack, i)
	}

	base_max = make([]int, q+1)
	for u := 0; u <= q; u++ {
		l := intervals[u].l
		r := intervals[u].r
		bMax := -2000000000

		currL := l
		for _, v := range children[u] {
			childL := intervals[v].l
			childR := intervals[v].r
			if currL <= childL-1 {
				val := query(currL, childL-1)
				if val > bMax {
					bMax = val
				}
			}
			currL = childR + 1
		}
		if currL <= r {
			val := query(currL, r)
			if val > bMax {
				bMax = val
			}
		}
		base_max[u] = bMax
	}

	SZ = 2*q + 1
	F_root := dfs(0)

	ans := 0.0
	for i := 0; i < SZ; i++ {
		prob := F_root[i]
		if i > 0 {
			prob -= F_root[i-1]
		}
		ans += prob * float64(offset+i)
	}

	fmt.Printf("%.9f\n", ans)
}
```