```go
package main

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

func min(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

type SegTree struct {
	tree []int64
	lazy []int64
	size int
}

func NewSegTree(n int) *SegTree {
	return &SegTree{
		tree: make([]int64, 4*n),
		lazy: make([]int64, 4*n),
		size: n,
	}
}

func (st *SegTree) build(node, l, r int, initVals []int64) {
	if l == r {
		st.tree[node] = initVals[l]
		return
	}
	mid := (l + r) / 2
	st.build(2*node, l, mid, initVals)
	st.build(2*node+1, mid+1, r, initVals)
	st.tree[node] = min(st.tree[2*node], st.tree[2*node+1])
}

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

func (st *SegTree) add(node, l, r, ql, qr int, val int64) {
	if ql <= l && r <= qr {
		st.tree[node] += val
		st.lazy[node] += val
		return
	}
	st.push(node)
	mid := (l + r) / 2
	if ql <= mid {
		st.add(2*node, l, mid, ql, qr, val)
	}
	if qr > mid {
		st.add(2*node+1, mid+1, r, ql, qr, val)
	}
	st.tree[node] = min(st.tree[2*node], st.tree[2*node+1])
}

func (st *SegTree) Add(ql, qr int, val int64) {
	if ql > qr {
		return
	}
	st.add(1, 0, st.size-1, ql, qr, val)
}

func (st *SegTree) GetMin() int64 {
	return st.tree[1]
}

type PointTree struct {
	tree []int64
	size int
}

func NewPointTree(n int) *PointTree {
	return &PointTree{
		tree: make([]int64, 4*(n+1)),
		size: n,
	}
}

func (pt *PointTree) build(node, l, r int, initVals []int64) {
	if l == r {
		pt.tree[node] = initVals[l]
		return
	}
	mid := (l + r) / 2
	pt.build(2*node, l, mid, initVals)
	pt.build(2*node+1, mid+1, r, initVals)
	pt.tree[node] = min(pt.tree[2*node], pt.tree[2*node+1])
}

func (pt *PointTree) update(node, l, r, idx int, val int64) {
	if l == r {
		pt.tree[node] = val
		return
	}
	mid := (l + r) / 2
	if idx <= mid {
		pt.update(2*node, l, mid, idx, val)
	} else {
		pt.update(2*node+1, mid+1, r, idx, val)
	}
	pt.tree[node] = min(pt.tree[2*node], pt.tree[2*node+1])
}

func (pt *PointTree) Update(idx int, val int64) {
	pt.update(1, 1, pt.size, idx, val)
}

func (pt *PointTree) GetMin() int64 {
	return pt.tree[1]
}

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

	scanInt := func() int {
		scanner.Scan()
		res, _ := strconv.Atoi(scanner.Text())
		return res
	}
	scanInt64 := func() int64 {
		scanner.Scan()
		res, _ := strconv.ParseInt(scanner.Text(), 10, 64)
		return res
	}

	if !scanner.Scan() {
		return
	}
	n, _ := strconv.Atoi(scanner.Text())
	m := scanInt()
	q := scanInt()

	x := make([]int64, n+1)
	yInit := make([]int64, n)

	for i := 1; i < n; i++ {
		x[i] = scanInt64()
		yInit[i] = scanInt64()
	}
	yInit[0] = 0
	x[n] = 0

	type Edge struct {
		to  int
		cap int64
	}
	adj := make([][]Edge, n+1)
	for i := 0; i < m; i++ {
		u := scanInt()
		v := scanInt()
		c := scanInt64()
		adj[u] = append(adj[u], Edge{v, c})
	}

	segE := NewSegTree(n)
	segE.build(1, 0, n-1, yInit)

	M := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		for _, edge := range adj[i] {
			segE.Add(0, edge.to-1, edge.cap)
		}
		M[i] = segE.GetMin()
	}

	vInit := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		vInit[i] = x[i] + M[i]
	}

	segV := NewPointTree(n)
	segV.build(1, 1, n, vInit)

	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	fmt.Fprintln(out, segV.GetMin())

	for i := 0; i < q; i++ {
		v := scanInt()
		w := scanInt64()
		x[v] = w
		segV.Update(v, x[v]+M[v])
		fmt.Fprintln(out, segV.GetMin())
	}
}
```