```go
package main

import (
	"bufio"
	"io"
	"os"
)

type Scanner struct {
	buf []byte
	pos int
}

func NewScanner() *Scanner {
	buf, _ := io.ReadAll(os.Stdin)
	return &Scanner{buf: buf, pos: 0}
}

func (s *Scanner) nextInt() int {
	for s.pos < len(s.buf) && s.buf[s.pos] <= ' ' {
		s.pos++
	}
	if s.pos >= len(s.buf) {
		return 0
	}
	res := 0
	for s.pos < len(s.buf) && s.buf[s.pos] > ' ' {
		res = res*10 + int(s.buf[s.pos]-'0')
		s.pos++
	}
	return res
}

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

var tree []int
var lazy []int

func build(node, l, r int, P []int) {
	if l == r {
		tree[node] = P[l]
		return
	}
	mid := (l + r) / 2
	build(node*2, l, mid, P)
	build(node*2+1, mid+1, r, P)
	tree[node] = max(tree[node*2], tree[node*2+1])
}

func push(node int) {
	if lazy[node] != 0 {
		tree[node*2] += lazy[node]
		lazy[node*2] += lazy[node]
		tree[node*2+1] += lazy[node]
		lazy[node*2+1] += lazy[node]
		lazy[node] = 0
	}
}

func update(node, l, r, ql, qr, val int) {
	if ql <= l && r <= qr {
		tree[node] += val
		lazy[node] += val
		return
	}
	push(node)
	mid := (l + r) / 2
	if ql <= mid {
		update(node*2, l, mid, ql, qr, val)
	}
	if qr > mid {
		update(node*2+1, mid+1, r, ql, qr, val)
	}
	tree[node] = max(tree[node*2], tree[node*2+1])
}

func main() {
	sc := NewScanner()
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	N := sc.nextInt()
	M := sc.nextInt()
	Q := sc.nextInt()

	A1 := sc.nextInt()
	C0 := 0
	for i := 2; i <= N; i++ {
		val := sc.nextInt()
		if val > A1 {
			C0++
		}
	}

	R := make([]int, M+1)
	B := make([][]int, M+1)
	C := make([]int, M+1)

	for i := 1; i <= M; i++ {
		R[i] = sc.nextInt()
		B[i] = make([]int, R[i]+1)
		for j := 1; j <= R[i]; j++ {
			B[i][j] = sc.nextInt()
			if B[i][j] > A1 {
				C[i]++
			}
		}
	}

	P := make([]int, M+1)
	pref := C0
	for i := 1; i <= M; i++ {
		P[i] = pref + R[i]
		pref += C[i]
	}

	tree = make([]int, 4*M+1)
	lazy = make([]int, 4*M+1)
	if M > 0 {
		build(1, 1, M, P)
	}

	for q := 0; q < Q; q++ {
		X := sc.nextInt()
		Y := sc.nextInt()
		Z := sc.nextInt()

		oldVal := B[X][Y]
		delta := 0
		if oldVal > A1 && Z < A1 {
			delta = -1
		} else if oldVal < A1 && Z > A1 {
			delta = 1
		}

		B[X][Y] = Z

		if delta != 0 && X < M {
			update(1, 1, M, X+1, M, delta)
		}

		if M > 0 {
			if tree[1] <= N-1 {
				out.WriteByte('1')
			} else {
				out.WriteByte('0')
			}
			out.WriteByte('\n')
		}
	}
}
```