```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

type Node struct {
	p, n, pn    int
	sp, sn, spn int
	ans         int
	len         int
}

var tree []Node
var b []int64
var reader *bufio.Reader

func nextInt() int {
	var res int
	var sign = 1
	var b byte
	for {
		b, _ = reader.ReadByte()
		if b == '-' || (b >= '0' && b <= '9') {
			break
		}
	}
	if b == '-' {
		sign = -1
	} else {
		res = int(b - '0')
	}
	for {
		b, _ = reader.ReadByte()
		if b < '0' || b > '9' {
			break
		}
		res = res*10 + int(b-'0')
	}
	return res * sign
}

func nextInt64() int64 {
	var res int64
	var sign int64 = 1
	var b byte
	for {
		b, _ = reader.ReadByte()
		if b == '-' || (b >= '0' && b <= '9') {
			break
		}
	}
	if b == '-' {
		sign = -1
	} else {
		res = int64(b - '0')
	}
	for {
		b, _ = reader.ReadByte()
		if b < '0' || b > '9' {
			break
		}
		res = res*10 + int64(b-'0')
	}
	return res * sign
}

func makeNode(val int64) Node {
	if val > 0 {
		return Node{1, 0, 1, 1, 0, 1, 1, 1}
	} else if val < 0 {
		return Node{0, 1, 1, 0, 1, 1, 1, 1}
	} else {
		return Node{0, 0, 0, 0, 0, 0, 0, 1}
	}
}

func merge(l, r Node) Node {
	var res Node
	res.len = l.len + r.len

	if l.p == l.len {
		res.p = l.len + r.p
		res.pn = l.len + r.pn
	} else {
		res.p = l.p
		if l.pn == l.len {
			res.pn = l.len + r.n
		} else {
			res.pn = l.pn
		}
	}

	if l.n == l.len {
		res.n = l.len + r.n
	} else {
		res.n = l.n
	}

	if r.sp == r.len {
		res.sp = r.len + l.sp
	} else {
		res.sp = r.sp
	}

	if r.sn == r.len {
		res.sn = r.len + l.sn
		res.spn = r.len + l.spn
	} else {
		res.sn = r.sn
		if r.spn == r.len {
			res.spn = r.len + l.sp
		} else {
			res.spn = r.spn
		}
	}

	ans := l.ans
	if r.ans > ans {
		ans = r.ans
	}

	bridge1 := l.sp + r.pn
	if bridge1 > ans {
		ans = bridge1
	}

	bridge2 := l.spn + r.n
	if bridge2 > ans {
		ans = bridge2
	}

	res.ans = ans

	return res
}

func build(node, start, end int) {
	if start == end {
		tree[node] = makeNode(b[start])
		return
	}
	mid := (start + end) / 2
	build(2*node, start, mid)
	build(2*node+1, mid+1, end)
	tree[node] = merge(tree[2*node], tree[2*node+1])
}

func update(node, start, end, idx int, val int64) {
	if start == end {
		tree[node] = makeNode(val)
		return
	}
	mid := (start + end) / 2
	if idx <= mid {
		update(2*node, start, mid, idx, val)
	} else {
		update(2*node+1, mid+1, end, idx, val)
	}
	tree[node] = merge(tree[2*node], tree[2*node+1])
}

func main() {
	reader = bufio.NewReaderSize(os.Stdin, 65536)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	n := nextInt()
	a := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		a[i] = nextInt64()
	}

	m := nextInt()

	if n == 1 {
		for i := 0; i < m; i++ {
			nextInt()
			nextInt()
			nextInt64()
			fmt.Fprintln(writer, 1)
		}
		return
	}

	b = make([]int64, n)
	for i := 1; i < n; i++ {
		b[i] = a[i+1] - a[i]
	}

	tree = make([]Node, 4*n)
	build(1, 1, n-1)

	for i := 0; i < m; i++ {
		l := nextInt()
		r := nextInt()
		d := nextInt64()

		if l > 1 {
			b[l-1] += d
			update(1, 1, n-1, l-1, b[l-1])
		}
		if r < n {
			b[r] -= d
			update(1, 1, n-1, r, b[r])
		}

		fmt.Fprintln(writer, tree[1].ans+1)
	}
}
```