```go
package main

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

type FastScanner struct {
	data []byte
	idx  int
}

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

func (fs *FastScanner) NextToken() []byte {
	n := len(fs.data)
	i := fs.idx
	for i < n && fs.data[i] <= ' ' {
		i++
	}
	start := i
	for i < n && fs.data[i] > ' ' {
		i++
	}
	fs.idx = i
	return fs.data[start:i]
}

func zeroEdges2(a, b []int64, n, m int, rowOff []int) {
	for j := 0; j <= m; j++ {
		a[j] = 0
		b[j] = 0
	}
	for i := 1; i <= n; i++ {
		idx := rowOff[i]
		a[idx] = 0
		b[idx] = 0
	}
}

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

	n := fs.NextInt()
	m := fs.NextInt()
	k := fs.NextInt()

	H := n + 2
	W := m + 2
	size := H * W

	rowOff := make([]int, H)
	for i := 0; i < H; i++ {
		rowOff[i] = i * W
	}

	tgrid := make([]byte, size)
	for i := 1; i <= n; i++ {
		s := fs.NextToken()
		base := rowOff[i]
		for j := 0; j < m; j++ {
			tgrid[base+1+j] = s[j] - 'a'
		}
	}

	totalCnt := make([]int32, size)
	byColor := make([]int32, 26*size)

	x1 := make([]int, k)
	y1 := make([]int, k)
	x2 := make([]int, k)
	y2 := make([]int, k)
	paint := make([]byte, k)

	var groups [26][]int

	for i := 0; i < k; i++ {
		a := fs.NextInt()
		b := fs.NextInt()
		c := fs.NextInt()
		d := fs.NextInt()
		e := fs.NextToken()[0] - 'a'

		x1[i], y1[i], x2[i], y2[i] = a, b, c, d
		paint[i] = e
		groups[e] = append(groups[e], i)

		idx1 := rowOff[a] + b
		idx2 := rowOff[c+1] + b
		idx3 := rowOff[a] + d + 1
		idx4 := rowOff[c+1] + d + 1

		totalCnt[idx1]++
		totalCnt[idx2]--
		totalCnt[idx3]--
		totalCnt[idx4]++

		base := int(e) * size
		byColor[base+idx1]++
		byColor[base+idx2]--
		byColor[base+idx3]--
		byColor[base+idx4]++
	}

	active := make([]int, 0, 26)
	for c := 0; c < 26; c++ {
		if len(groups[c]) > 0 {
			active = append(active, c)
		}
	}

	for i := 1; i <= n; i++ {
		cur := totalCnt[rowOff[i] : rowOff[i]+W]
		up := totalCnt[rowOff[i-1] : rowOff[i-1]+W]
		for j := 1; j <= m; j++ {
			cur[j] += cur[j-1] + up[j] - up[j-1]
		}
	}

	for _, c := range active {
		d := byColor[c*size : (c+1)*size]
		for i := 1; i <= n; i++ {
			cur := d[rowOff[i] : rowOff[i]+W]
			up := d[rowOff[i-1] : rowOff[i-1]+W]
			for j := 1; j <= m; j++ {
				cur[j] += cur[j-1] + up[j] - up[j-1]
			}
		}
	}

	var dist [26][26]int64
	for i := 0; i < 26; i++ {
		for j := 0; j < 26; j++ {
			if i > j {
				dist[i][j] = int64(i - j)
			} else {
				dist[i][j] = int64(j - i)
			}
		}
	}

	sArr := make([]int64, k)
	adj := make([]int64, k)

	p1 := make([]int64, size)
	p2 := make([]int64, size)

	var totalS int64

	for _, a := range active {
		zeroEdges2(p1, p2, n, m, rowOff)
		wrow := dist[a]

		for i := 1; i <= n; i++ {
			row := rowOff[i]
			prev := rowOff[i-1]
			cur1 := p1[row : row+W]
			cur2 := p2[row : row+W]
			up1 := p1[prev : prev+W]
			up2 := p2[prev : prev+W]
			tg := tgrid[row : row+W]
			cov := totalCnt[row : row+W]

			for j := 1; j <= m; j++ {
				b := wrow[tg[j]]
				cur1[j] = b + cur1[j-1] + up1[j] - up1[j-1]
				cur2[j] = int64(cov[j])*b + cur2[j-1] + up2[j] - up2[j-1]
			}
		}

		for _, id := range groups[a] {
			r0 := rowOff[x1[id]-1]
			r1 := rowOff[x2[id]]
			l := y1[id] - 1
			rr := y2[id]

			q1 := p1[r1+rr] - p1[r0+rr] - p1[r1+l] + p1[r0+l]
			q2 := p2[r1+rr] - p2[r0+rr] - p2[r1+l] + p2[r0+l]

			sArr[id] = q1
			totalS += q1
			adj[id] -= q2
		}
	}

	for _, c := range active {
		zeroEdges2(p1, p2, n, m, rowOff)
		wrow := dist[c]
		d := byColor[c*size : (c+1)*size]

		for i := 1; i <= n; i++ {
			row := rowOff[i]
			prev := rowOff[i-1]
			cur1 := p1[row : row+W]
			cur2 := p2[row : row+W]
			up1 := p1[prev : prev+W]
			up2 := p2[prev : prev+W]
			tg := tgrid[row : row+W]
			dc := d[row : row+W]

			for j := 1; j <= m; j++ {
				cnt := int64(dc[j])
				cur1[j] = cnt + cur1[j-1] + up1[j] - up1[j-1]
				cur2[j] = cnt*wrow[tg[j]] + cur2[j-1] + up2[j] - up2[j-1]
			}
		}

		for id := 0; id < k; id++ {
			r0 := rowOff[x1[id]-1]
			r1 := rowOff[x2[id]]
			l := y1[id] - 1
			rr := y2[id]

			q1 := p1[r1+rr] - p1[r0+rr] - p1[r1+l] + p1[r0+l]
			q2 := p2[r1+rr] - p2[r0+rr] - p2[r1+l] + p2[r0+l]

			adj[id] += wrow[paint[id]]*q1 - q2
		}
	}

	ans := int64(1 << 62)
	kk := int64(k)
	for i := 0; i < k; i++ {
		v := kk*sArr[i] + totalS + adj[i]
		if v < ans {
			ans = v
		}
	}

	os.Stdout.WriteString(strconv.FormatInt(ans, 10))
}
```