package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"sort"
	"strconv"
	"strings"
)

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var n, k int
	if _, err := fmt.Fscan(in, &n, &k); err != nil {
		return
	}
	a := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Fscan(in, &a[i])
	}
	m := n / k

	var q int
	fmt.Fscan(in, &q)

	used := make([]bool, n)
	seen := make(map[string]bool)
	minKnown := math.Inf(1)
	maxKnown := math.Inf(-1)

	for i := 0; i < q; i++ {
		idx := make([]int, m)
		for j := 0; j < m; j++ {
			fmt.Fscan(in, &idx[j])
			idx[j]--
		}
		sort.Ints(idx)
		var b strings.Builder
		for j := 0; j < m; j++ {
			if j > 0 {
				b.WriteByte(',')
			}
			b.WriteString(strconv.Itoa(idx[j]))
		}
		key := b.String()
		if !seen[key] {
			seen[key] = true
			sum := 0
			for j := 0; j < m; j++ {
				used[idx[j]] = true
				sum += a[idx[j]]
			}
			avg := float64(sum) / float64(m)
			if avg < minKnown {
				minKnown = avg
			}
			if avg > maxKnown {
				maxKnown = avg
			}
		}
	}

	remain := []int{}
	for i := 0; i < n; i++ {
		if !used[i] {
			remain = append(remain, a[i])
		}
	}

	var minUnknown, maxUnknown float64
	if k-len(seen) > 0 {
		sort.Ints(remain)
		sumSmall := 0
		for i := 0; i < m; i++ {
			sumSmall += remain[i]
		}
		sumLarge := 0
		L := len(remain)
		for i := 0; i < m; i++ {
			sumLarge += remain[L-1-i]
		}
		minUnknown = float64(sumSmall) / float64(m)
		maxUnknown = float64(sumLarge) / float64(m)
	} else {
		minUnknown = math.Inf(1)
		maxUnknown = math.Inf(-1)
	}

	ansMin := math.Min(minKnown, minUnknown)
	ansMax := math.Max(maxKnown, maxUnknown)

	fmt.Fprintf(out, "%.10f %.10f\n", ansMin, ansMax)
}