```go
package main

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

type FastScanner struct {
	data []byte
	idx  int
}

func NewFastScanner() *FastScanner {
	b, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: b}
}

func (fs *FastScanner) NextInt() int {
	for fs.idx < len(fs.data) && fs.data[fs.idx] <= ' ' {
		fs.idx++
	}
	sign := 1
	if fs.data[fs.idx] == '-' {
		sign = -1
		fs.idx++
	}
	v := 0
	for fs.idx < len(fs.data) {
		c := fs.data[fs.idx]
		if c < '0' || c > '9' {
			break
		}
		v = v*10 + int(c-'0')
		fs.idx++
	}
	return v * sign
}

type Edge struct {
	a int
	b int
	w int64
}

type Query struct {
	v int
	l int64
}

func main() {
	fs := NewFastScanner()
	n := fs.NextInt()
	m := fs.NextInt()

	const INF int64 = 1 << 60

	dist := make([]int64, n*n)
	for i := range dist {
		dist[i] = INF
	}
	for i := 0; i < n; i++ {
		dist[i*n+i] = 0
	}

	edges := make([]Edge, m)
	for i := 0; i < m; i++ {
		u := fs.NextInt() - 1
		v := fs.NextInt() - 1
		w := int64(fs.NextInt())
		edges[i] = Edge{u, v, w}
		dist[u*n+v] = w
		dist[v*n+u] = w
	}

	for k := 0; k < n; k++ {
		rowK := dist[k*n : k*n+n]
		for i := 0; i < n; i++ {
			rowI := dist[i*n : i*n+n]
			dik := rowI[k]
			if dik == INF {
				continue
			}
			for j := 0; j < n; j++ {
				nd := dik + rowK[j]
				if nd < rowI[j] {
					rowI[j] = nd
				}
			}
		}
	}

	q := fs.NextInt()
	queriesByU := make([][]Query, n)
	for i := 0; i < q; i++ {
		u := fs.NextInt() - 1
		v := fs.NextInt() - 1
		l := int64(fs.NextInt())
		queriesByU[u] = append(queriesByU[u], Query{v, l})
	}

	useful := make([]bool, m)
	ans := 0
	mx := make([]int64, n)

	for s := 0; s < n && ans < m; s++ {
		qs := queriesByU[s]
		if len(qs) == 0 {
			continue
		}

		for i := 0; i < n; i++ {
			mx[i] = -INF
		}

		for _, qq := range qs {
			rowV := dist[qq.v*n : qq.v*n+n]
			lim := qq.l
			for x := 0; x < n; x++ {
				val := lim - rowV[x]
				if val > mx[x] {
					mx[x] = val
				}
			}
		}

		rowS := dist[s*n : s*n+n]
		for i, e := range edges {
			if useful[i] {
				continue
			}
			if rowS[e.a]+e.w <= mx[e.b] || rowS[e.b]+e.w <= mx[e.a] {
				useful[i] = true
				ans++
			}
		}
	}

	out := bufio.NewWriterSize(os.Stdout, 32)
	out.WriteString(strconv.Itoa(ans))
	out.Flush()
}
```