package main

import (
	"fmt"
	"io"
	"os"
	"sort"
)

func max(a, b int32) int32 {
	if a > b {
		return a
	}
	return b
}

func min(a, b int32) int32 {
	if a < b {
		return a
	}
	return b
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0

	nextInt := func() int {
		for idx < len(data) && data[idx] <= ' ' {
			idx++
		}
		if idx >= len(data) {
			return 0
		}
		res := 0
		for idx < len(data) && data[idx] > ' ' {
			res = res*10 + int(data[idx]-'0')
			idx++
		}
		return res
	}

	n := nextInt()
	if n == 0 {
		return
	}
	k := nextInt()

	V := make([]int32, n)
	for i := 0; i < n; i++ {
		V[i] = int32(nextInt())
	}

	C := make([]int32, n)
	for i := 0; i < n; i++ {
		C[i] = int32(nextInt())
	}

	lg := make([]int, n+1)
	if n > 0 {
		lg[1] = 0
		for i := 2; i <= n; i++ {
			lg[i] = lg[i/2] + 1
		}
	}

	stV := make([][]int32, lg[n]+1)
	stC := make([][]int32, lg[n]+1)
	for i := 0; i <= lg[n]; i++ {
		stV[i] = make([]int32, n-(1<<i)+1)
		stC[i] = make([]int32, n-(1<<i)+1)
	}

	for i := 0; i < n; i++ {
		stV[0][i] = V[i]
		stC[0][i] = C[i]
	}

	for i := 1; i <= lg[n]; i++ {
		for j := 0; j+(1<<i) <= n; j++ {
			stV[i][j] = max(stV[i-1][j], stV[i-1][j+(1<<(i-1))])
			stC[i][j] = min(stC[i-1][j], stC[i-1][j+(1<<(i-1))])
		}
	}

	queryV := func(l, r int) int32 {
		pow := lg[r-l+1]
		return max(stV[pow][l], stV[pow][r-(1<<pow)+1])
	}

	queryC := func(l, r int) int32 {
		pow := lg[r-l+1]
		return min(stC[pow][l], stC[pow][r-(1<<pow)+1])
	}

	M := make([]int32, n)
	for l := 0; l < n; l++ {
		if 100*stV[0][l] > stC[0][l] {
			M[l] = stC[0][l]
		} else {
			low, high := l, n-1
			res := l
			for low <= high {
				mid := (low + high) / 2
				maxV := queryV(l, mid)
				minC := queryC(l, mid)
				if 100*maxV <= minC {
					res = mid
					low = mid + 1
				} else {
					high = mid - 1
				}
			}

			val1 := 100 * queryV(l, res)
			if res < n-1 {
				val2 := queryC(l, res+1)
				if val2 > val1 {
					val1 = val2
				}
			}
			M[l] = val1
		}
	}

	sort.Slice(M, func(i, j int) bool {
		return M[i] < M[j]
	})

	p := float64(k) / float64(n)
	ans := p * float64(M[0])
	for i := 1; i <= n-k; i++ {
		p = p * float64(n-i-k+1) / float64(n-i)
		ans += p * float64(M[i])
	}

	fmt.Printf("%.9f\n", ans)
}