```go
package main

import (
	"bytes"
	"io"
	"os"
)

const INF int = 1 << 60

type FastScanner struct {
	data []byte
	idx  int
}

func (fs *FastScanner) nextInt() int {
	n := len(fs.data)
	for fs.idx < n && fs.data[fs.idx] <= ' ' {
		fs.idx++
	}
	sign := 1
	if fs.data[fs.idx] == '-' {
		sign = -1
		fs.idx++
	}
	val := 0
	for fs.idx < n {
		c := fs.data[fs.idx]
		if c <= ' ' {
			break
		}
		val = val*10 + int(c-'0')
		fs.idx++
	}
	return val * sign
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	fs := FastScanner{data: data}

	n := fs.nextInt()
	m := fs.nextInt()

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

	for i := 0; i < m; i++ {
		x := fs.nextInt() - 1
		y := fs.nextInt() - 1
		z := fs.nextInt()
		idx := y*n + x
		if z < dir[idx] {
			dir[idx] = z
		}
		if z < dist[idx] {
			dist[idx] = z
		}
	}

	for k := 0; k < n; k++ {
		krow := dist[k*n : (k+1)*n]
		for i := 0; i < n; i++ {
			irow := dist[i*n : (i+1)*n]
			ik := irow[k]
			if ik >= INF {
				continue
			}
			for j := 0; j < n; j++ {
				nv := ik + krow[j]
				if nv < irow[j] {
					irow[j] = nv
				}
			}
		}
	}

	for i := 0; i < nn; i++ {
		if dist[i] >= dir[i] {
			dist[i] = INF
		}
	}

	q := fs.nextInt()

	a := make([]int, n)
	b := make([]int, n)
	c := make([]int, n)
	ans := make([]byte, n)

	var out bytes.Buffer
	out.Grow(q * (n + 1))

	for ; q > 0; q-- {
		k := fs.nextInt()
		for i := 0; i < n; i++ {
			a[i] = fs.nextInt()
			b[i] = INF
			c[i] = INF
		}

		for s := 0; s < n; s++ {
			as := a[s]
			qrow := dir[s*n : (s+1)*n]
			drow := dist[s*n : (s+1)*n]
			for v := 0; v < n; v++ {
				v1 := as + qrow[v]
				if v1 < b[v] {
					b[v] = v1
				}
				v2 := as + drow[v]
				if v2 < c[v] {
					c[v] = v2
				}
			}
		}

		for i := 0; i < n; i++ {
			if c[i] < b[i]+k {
				ans[i] = '1'
			} else {
				ans[i] = '0'
			}
		}
		out.Write(ans)
		out.WriteByte('\n')
	}

	os.Stdout.Write(out.Bytes())
}
```