```go
package main

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

func main() {
	data, _ := io.ReadAll(os.Stdin)
	p := 0
	nextInt := func() int {
		n := len(data)
		for p < n {
			c := data[p]
			if c > ' ' {
				break
			}
			p++
		}
		sign := 1
		if p < n && data[p] == '-' {
			sign = -1
			p++
		}
		val := 0
		for p < n {
			c := data[p]
			if c < '0' || c > '9' {
				break
			}
			val = val*10 + int(c-'0')
			p++
		}
		return sign * val
	}
	nextToken := func() []byte {
		n := len(data)
		for p < n && data[p] <= ' ' {
			p++
		}
		start := p
		for p < n && data[p] > ' ' {
			p++
		}
		return data[start:p]
	}

	n := nextInt()
	k := nextInt()
	s := nextToken()
	q := nextInt()

	// Build nxt: size (n+1) x k
	nxt := make([]int32, (n+1)*k)
	nextPos := make([]int32, k)
	for c := 0; c < k; c++ {
		nextPos[c] = int32(n + 1)
	}
	for i := n; i >= 0; i-- {
		base := i * k
		for c := 0; c < k; c++ {
			nxt[base+c] = nextPos[c]
		}
		if i > 0 {
			ch := int(s[i-1] - 'a')
			nextPos[ch] = int32(i)
		}
	}

	// Build dp: dp[i] = 1 + min_c dp[nxt[i][c]], dp[n+1] = 0
	dp := make([]int32, n+2)
	for i := n; i >= 0; i-- {
		base := i * k
		mn := int32(1 << 30)
		for c := 0; c < k; c++ {
			j := int(nxt[base+c])
			if dp[j] < mn {
				mn = dp[j]
			}
		}
		dp[i] = mn + 1
	}

	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	writeInt := func(v int) {
		if v == 0 {
			out.WriteByte('0')
			out.WriteByte('\n')
			return
		}
		var b [20]byte
		i := len(b)
		for v > 0 {
			i--
			b[i] = byte('0' + v%10)
			v /= 10
		}
		out.Write(b[i:])
		out.WriteByte('\n')
	}

	for i := 0; i < q; i++ {
		t := nextToken()
		pos := 0
		for _, bb := range t {
			c := int(bb - 'a')
			pos = int(nxt[pos*k+c])
			if pos == n+1 {
				break
			}
		}
		if pos == n+1 {
			writeInt(0)
		} else {
			writeInt(int(dp[pos]))
		}
	}
	out.Flush()
}
```