#define HEADER_H
//#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define REP(i,n)	for(auto i=decltype(n)(0); i<(n); ++i)
#define all(v)		begin(v), end(v)
using namespace std;		using ull= unsigned long long;
using ll = int;		using ld = long double;
using vi = vector<ll>;		using vvi= vector<vi>;
using vb = vector<bool>;	using ii = pair<ll,ll>;
constexpr bool LOG = true;
void Log() { if(LOG) cerr << "\n"; }
template<class T, class... S> void Log(T t, S... s){
	if(LOG) cerr << t << "\t", Log(s...);
} /* ============== END OF HEADER ============== */

int read(){
	int x; scanf("%d",&x);
	return x;
}

template <class T, T(*op)(T, T), T ident>
struct SegmentTree {
	int n; vector<T> tree;
	SegmentTree(vector<T> &init) : n(init.size()), tree(2 * n, ident) {
		copy(init.begin(), init.end(), tree.begin() + n);
		for (int j = n - 1; j > 0; --j)
			tree[j] = op(tree[2*j], tree[2*j+1]);
	}
	void update(int i, T val) {
		for (tree[i+n] = val, i = (i+n)/2; i > 0; i /= 2)
			tree[i] = op(tree[2*i], tree[2*i+1]);
	}
	T query(int l, int r) {
		T lhs = T(ident), rhs = T(ident);
		for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
			if (  l&1 ) lhs = op(lhs, tree[l++]);
			if (!(r&1)) rhs = op(tree[r--], rhs);
		}
		return op(l == r ? op(lhs, tree[l]) : lhs, rhs);
	}
};

int mymin(int l, int r){ return min(l,r); }
int mymax(int l, int r){ return max(l,r); }

ld binom(int a, int b){
	if(a < 0 || b<0 || b>a) return 0;
	ld ans = 1;
	b = min(b, a-b);
	for(int i = 0; i < b; ++i)
		ans *= (a-i), ans /= i+1;
	return ans;
}

const int MC = 50;
int main(){
	ios_base::sync_with_stdio(false); cin.tie(nullptr);
	ll n = read(), k=read();
	vi v(n),c(n);
	for(auto &x : v) x = read();
	for(auto &x : c) x = read();

	SegmentTree<int,mymax,0> stv(v);
	SegmentTree<int,mymin,1000000000> stc(c);

	vi bestval(n);
	for(int i = 0; i < n; ++i){
		// binary search
		ll l=i, r = n-1;	// r inclusive
		ll best = -1;
		while(r-l > 1){
			ll m = (l+r)/2;
			ll q1 = 100*stv.query(i,m);
			ll q2 = stc.query(i,m);
			if(q1 > q2)
				r = m;
			else
				l = m;
			best = max(best, min(q1,q2));
		}
		for(; l <=r; ++l )
			best = max(best, min(100*stv.query(i,l), stc.query(i,l)));
		bestval[i] = best;
	}

	sort(all(bestval));

	ld ans = 0;

	ld sump= 0;
	ld bs = 1;
	REP(i,n){
		// probability that i is a minimum of k elements
		ld p=0;
		//p = ld(k)/ld(n) * binom(n-i-1, k-1) / binom(n-1, k-1);
		p = ld(k)/ld(n) * bs;
		Log(i,p);
		sump+=p;
		ans += p * bestval[i];
		bs *= ld(n-k-i)/ld(n-1-i);
	}
	cerr << fixed << setprecision(15) << sump << endl;
	assert(abs(sump-1) < 1e-12);
	//Log("sump",sump);

	cout << fixed << setprecision(15) << ans << endl;

	return 0;
}


#define HEADER_H
//#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define REP(i,n)	for(auto i=decltype(n)(0); i<(n); ++i)
#define all(v)		begin(v), end(v)
using namespace std;		using ull= unsigned long long;
using ll = int;		using ld = long double;
using vi = vector<ll>;		using vvi= vector<vi>;
using vb = vector<bool>;	using ii = pair<ll,ll>;
constexpr bool LOG = true;
void Log() { if(LOG) cerr << "\n"; }
template<class T, class... S> void Log(T t, S... s){
	if(LOG) cerr << t << "\t", Log(s...);
} /* ============== END OF HEADER ============== */

int read(){
	int x; scanf("%d",&x);
	return x;
}

template <class T, T(*op)(T, T), T ident>
struct SegmentTree {
	int n; vector<T> tree;
	SegmentTree(vector<T> &init) : n(init.size()), tree(2 * n, ident) {
		copy(init.begin(), init.end(), tree.begin() + n);
		for (int j = n - 1; j > 0; --j)
			tree[j] = op(tree[2*j], tree[2*j+1]);
	}
	void update(int i, T val) {
		for (tree[i+n] = val, i = (i+n)/2; i > 0; i /= 2)
			tree[i] = op(tree[2*i], tree[2*i+1]);
	}
	T query(int l, int r) {
		T lhs = T(ident), rhs = T(ident);
		for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
			if (  l&1 ) lhs = op(lhs, tree[l++]);
			if (!(r&1)) rhs = op(tree[r--], rhs);
		}
		return op(l == r ? op(lhs, tree[l]) : lhs, rhs);
	}
};

int mymin(int l, int r){ return min(l,r); }
int mymax(int l, int r){ return max(l,r); }

ld binom(int a, int b){
	if(a < 0 || b<0 || b>a) return 0;
	ld ans = 1;
	b = min(b, a-b);
	for(int i = 0; i < b; ++i)
		ans *= (a-i), ans /= i+1;
	return ans;
}

const int MC = 20;
int main(){
	ios_base::sync_with_stdio(false); cin.tie(nullptr);
	ll n = read(), k=read();
	vi v(n),c(n);
	for(auto &x : v) x = read();
	for(auto &x : c) x = read();

	SegmentTree<int,mymax,0> stv(v);
	SegmentTree<int,mymin,1000000000> stc(c);

	vi bestval(n);
	for(int i = 0; i < n; ++i){
		// ternary search for r
		ll l=i, r = n-1;	// r inclusive
		while(r-l > MC){
			ll m1 = (l+l+r)/3;
			ll m2 = (l+r+r)/3;
			ll v1 = min(100*stv.query(i,m1), stc.query(i,m1));
			ll v2 = min(100*stv.query(i,m2), stc.query(i,m2));
			if(v1 > v2)
				r = m2;
			else
				l = m1;
		}
		int best = -1;
		for(; l <=r; ++l )
			best = max(best, min(100*stv.query(i,l), stc.query(i,l)));
		bestval[i] = best;
	}

	sort(all(bestval));

	ld ans = 0;

	ld sump= 0;
	REP(i,n){
		// probability that i is a minimum of k elements
		ld p=0;
		p = ld(k)/ld(n) * binom(n-i-1, k-1) / binom(n-1, k-1);
		//Log(i,p);
		sump+=p;
		ans += p * bestval[i];
	}
	assert(abs(sump-1) < 1e-12);
	//Log("sump",sump);

	cout << fixed << setprecision(15) << ans << endl;

	return 0;
}


#define HEADER_H
//#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define REP(i,n)	for(auto i=decltype(n)(0); i<(n); ++i)
#define all(v)		begin(v), end(v)
using namespace std;		using ull= unsigned long long;
using ll = int;		using ld = long double;
using vi = vector<ll>;		using vvi= vector<vi>;
using vb = vector<bool>;	using ii = pair<ll,ll>;
constexpr bool LOG = true;
void Log() { if(LOG) cerr << "\n"; }
template<class T, class... S> void Log(T t, S... s){
	if(LOG) cerr << t << "\t", Log(s...);
} /* ============== END OF HEADER ============== */

int read(){
	int x; scanf("%d",&x);
	return x;
}

using T = int;
using vt = vector<T>; using vvt = vector<vt>;
struct SparseTable{
	vvt d;
	SparseTable(vt &a) : d(vvt{a}) {
		int N = a.size();
		for(auto s = 1; 2*s <= N; s *= 2){
			d.push_back(vt(N - 2*s + 1));
			auto &n = d.back(); auto &l = d[d.size()-2];
			for(int i = 0; i + 2*s<=N; ++i) n[i] = min(l[i], l[i+s]);
		}
	}
	int rmq(int l, int r){ // 0 <= l <= r < a.size()
		int p = 8*sizeof(int) - 1 - __builtin_clz(r+1-l);
		return min(d[p][l], d[p][r+1-(1<<p)]);
	}
};

int mymin(int l, int r){ return min(l,r); }
int mymax(int l, int r){ return max(l,r); }

int main(){
	ios_base::sync_with_stdio(false); cin.tie(nullptr);
	ll n = read(), k=read();
	vi v(n),c(n);
	for(auto &x : v) x = -read();
	for(auto &x : c) x = read();

	SparseTable stv(v),stc(c);

	vi bestval(n);
	for(int i = 0; i < n; ++i){
		// binary search
		ll l=i, r = n-1;	// r inclusive
		ll best = -1;
		while(r-l > 1){
			ll m = (l+r)/2;
			ll q1 = -100*stv.rmq(i,m);
			ll q2 = stc.rmq(i,m);
			if(q1 > q2)
				r = m;
			else
				l = m;
			best = max(best, min(q1,q2));
		}
		for(; l <=r; ++l )
			best = max(best, min(-100*stv.rmq(i,l), stc.rmq(i,l)));
		bestval[i] = best;
	}

	sort(all(bestval));

	ld ans = 0;

	ld sump= 0;
	ld bs = 1;
	REP(i,n){
		// probability that i is a minimum of k elements
		ld p=0;
		//p = ld(k)/ld(n) * binom(n-i-1, k-1) / binom(n-1, k-1);
		p = ld(k)/ld(n) * bs;
		sump+=p;
		ans += p * bestval[i];
		bs *= ld(n-k-i)/ld(n-1-i);
	}
	assert(abs(sump-1) < 1e-12);

	cout << fixed << setprecision(15) << ans << endl;

	return 0;
}


#define HEADER_H
//#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define REP(i,n)	for(auto i=decltype(n)(0); i<(n); ++i)
#define all(v)		begin(v), end(v)
using namespace std;		using ull= unsigned long long;
using ll = int;		using ld = long double;
using vi = vector<ll>;		using vvi= vector<vi>;
using vb = vector<bool>;	using ii = pair<ll,ll>;
constexpr bool LOG = true;
void Log() { if(LOG) cerr << "\n"; }
template<class T, class... S> void Log(T t, S... s){
	if(LOG) cerr << t << "\t", Log(s...);
} /* ============== END OF HEADER ============== */

int read(){
	int x; scanf("%d",&x);
	return x;
}

template <class T, T(*op)(T, T), T ident>
struct SegmentTree {
	int n; vector<T> tree;
	SegmentTree(vector<T> &init) : n(init.size()), tree(2 * n, ident) {
		copy(init.begin(), init.end(), tree.begin() + n);
		for (int j = n - 1; j > 0; --j)
			tree[j] = op(tree[2*j], tree[2*j+1]);
	}
	void update(int i, T val) {
		for (tree[i+n] = val, i = (i+n)/2; i > 0; i /= 2)
			tree[i] = op(tree[2*i], tree[2*i+1]);
	}
	T query(int l, int r) {
		T lhs = T(ident), rhs = T(ident);
		for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
			if (  l&1 ) lhs = op(lhs, tree[l++]);
			if (!(r&1)) rhs = op(tree[r--], rhs);
		}
		return op(l == r ? op(lhs, tree[l]) : lhs, rhs);
	}
};

int mymin(int l, int r){ return min(l,r); }
int mymax(int l, int r){ return max(l,r); }

ld binom(int a, int b){
	if(a < 0 || b<0 || b>a) return 0;
	ld ans = 1;
	b = min(b, a-b);
	for(int i = 0; i < b; ++i)
		ans *= (a-i), ans /= i+1;
	return ans;
}

const int MC = 6;
int main(){
	ios_base::sync_with_stdio(false); cin.tie(nullptr);
	ll n = read(), k=read();
	vi v(n),c(n);
	for(auto &x : v) x = read();
	for(auto &x : c) x = read();

	SegmentTree<int,mymin,1000000000> stv(v);
	SegmentTree<int,mymax,0> stc(c);

	vi bestval(n);
	for(int i = 0; i < n; ++i){
		// ternary search for r
		ll l=i, r = n-1;	// r inclusive
		while(r-l > MC){
			ll m1 = (l+l+r)/3;
			ll m2 = (l+r+r)/3;
			ll v1 = min(100*stv.query(i,m1), stc.query(i,m1));
			ll v2 = min(100*stv.query(i,m2), stc.query(i,m2));
			if(v1 > v2)
				r = m2;
			else
				l = m1;
		}
		int best = -1;
		for(; l <=r; ++l )
			best = max(best, min(100*stv.query(i,l), stc.query(i,l)));
		bestval[i] = best;
	}

	sort(all(bestval));

	ld ans = 0;

	ld sump= 0;
	REP(i,n){
		// probability that i is a minimum of k elements
		ld p=0;
		p = ld(k)/n * binom(n-i-1, k-1) / binom(n-1, k-1);
		//Log(i,p);
		sump+=p;
		ans += p * bestval[i];
	}
	//Log("sump",sump);

	cout << fixed << setprecision(15) << ans << endl;

	return 0;
}


#define HEADER_H
//#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define REP(i,n)	for(auto i=decltype(n)(0); i<(n); ++i)
#define all(v)		begin(v), end(v)
using namespace std;		using ull= unsigned long long;
using ll = int;		using ld = long double;
using vi = vector<ll>;		using vvi= vector<vi>;
using vb = vector<bool>;	using ii = pair<ll,ll>;
constexpr bool LOG = true;
void Log() { if(LOG) cerr << "\n"; }
template<class T, class... S> void Log(T t, S... s){
	if(LOG) cerr << t << "\t", Log(s...);
} /* ============== END OF HEADER ============== */

int read(){
	int x; scanf("%d",&x);
	return x;
}

template <class T, T(*op)(T, T), T ident>
struct SegmentTree {
	int n; vector<T> tree;
	SegmentTree(vector<T> &init) : n(init.size()), tree(2 * n, ident) {
		copy(init.begin(), init.end(), tree.begin() + n);
		for (int j = n - 1; j > 0; --j)
			tree[j] = op(tree[2*j], tree[2*j+1]);
	}
	void update(int i, T val) {
		for (tree[i+n] = val, i = (i+n)/2; i > 0; i /= 2)
			tree[i] = op(tree[2*i], tree[2*i+1]);
	}
	T query(int l, int r) {
		T lhs = T(ident), rhs = T(ident);
		for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
			if (  l&1 ) lhs = op(lhs, tree[l++]);
			if (!(r&1)) rhs = op(tree[r--], rhs);
		}
		return op(l == r ? op(lhs, tree[l]) : lhs, rhs);
	}
};

int mymin(int l, int r){ return min(l,r); }
int mymax(int l, int r){ return max(l,r); }

ld binom(int a, int b){
	if(a < 0 || b<0 || b>a) return 0;
	ld ans = 1;
	b = min(b, a-b);
	for(int i = 0; i < b; ++i)
		ans *= (a-i), ans /= i+1;
	return ans;
}

const int MC = 50;
int main(){
	ios_base::sync_with_stdio(false); cin.tie(nullptr);
	ll n = read(), k=read();
	vi v(n),c(n);
	for(auto &x : v) x = read();
	for(auto &x : c) x = read();

	SegmentTree<int,mymax,0> stv(v);
	SegmentTree<int,mymin,1000000000> stc(c);

	vi bestval(n);
	for(int i = 0; i < n; ++i){
		// binary search
		ll l=i, r = n-1;	// r inclusive
		ll best = -1;
		while(r-l > 1){
			ll m = (l+r)/2;
			ll q1 = 100*stv.query(i,m);
			ll q2 = stc.query(i,m);
			if(q1 > q2)
				r = m;
			else
				l = m;
			best = max(best, min(q1,q2));
		}
		for(; l <=r; ++l )
			best = max(best, min(100*stv.query(i,l), stc.query(i,l)));
		bestval[i] = best;
	}

	sort(all(bestval));

	ld ans = 0;

	ld sump= 0;
	ld bs = 1;
	REP(i,n){
		// probability that i is a minimum of k elements
		ld p=0;
		//p = ld(k)/ld(n) * binom(n-i-1, k-1) / binom(n-1, k-1);
		p = ld(k)/ld(n) * bs;
		sump+=p;
		ans += p * bestval[i];
		bs *= ld(n-k-i)/ld(n-1-i);
	}
	assert(abs(sump-1) < 1e-12);

	cout << fixed << setprecision(15) << ans << endl;

	return 0;
}


#define HEADER_H
//#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define REP(i,n)	for(auto i=decltype(n)(0); i<(n); ++i)
#define all(v)		begin(v), end(v)
using namespace std;		using ull= unsigned long long;
using ll = int;		using ld = long double;
using vi = vector<ll>;		using vvi= vector<vi>;
using vb = vector<bool>;	using ii = pair<ll,ll>;
constexpr bool LOG = true;
void Log() { if(LOG) cerr << "\n"; }
template<class T, class... S> void Log(T t, S... s){
	if(LOG) cerr << t << "\t", Log(s...);
} /* ============== END OF HEADER ============== */

int read(){
	int x; scanf("%d",&x);
	return x;
}

template <class T, T(*op)(T, T), T ident>
struct SegmentTree {
	int n; vector<T> tree;
	SegmentTree(vector<T> &init) : n(init.size()), tree(2 * n, ident) {
		copy(init.begin(), init.end(), tree.begin() + n);
		for (int j = n - 1; j > 0; --j)
			tree[j] = op(tree[2*j], tree[2*j+1]);
	}
	void update(int i, T val) {
		for (tree[i+n] = val, i = (i+n)/2; i > 0; i /= 2)
			tree[i] = op(tree[2*i], tree[2*i+1]);
	}
	T query(int l, int r) {
		T lhs = T(ident), rhs = T(ident);
		for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
			if (  l&1 ) lhs = op(lhs, tree[l++]);
			if (!(r&1)) rhs = op(tree[r--], rhs);
		}
		return op(l == r ? op(lhs, tree[l]) : lhs, rhs);
	}
};

int mymin(int l, int r){ return min(l,r); }
int mymax(int l, int r){ return max(l,r); }

ld binom(int a, int b){
	if(a < 0 || b<0 || b>a) return 0;
	ld ans = 1;
	b = min(b, a-b);
	for(int i = 0; i < b; ++i)
		ans *= (a-i), ans /= i+1;
	return ans;
}

const int MC = 20;
int main(){
	ios_base::sync_with_stdio(false); cin.tie(nullptr);
	ll n = read(), k=read();
	vi v(n),c(n);
	for(auto &x : v) x = read();
	for(auto &x : c) x = read();

	SegmentTree<int,mymax,0> stv(v);
	SegmentTree<int,mymin,1000000000> stc(c);

	vi bestval(n);
	for(int i = 0; i < n; ++i){
		// ternary search for r
		ll l=i, r = n-1;	// r inclusive
		while(r-l > MC){
			ll m1 = (l+l+r)/3;
			ll m2 = (l+r+r)/3;
			ll v1 = min(100*stv.query(i,m1), stc.query(i,m1));
			ll v2 = min(100*stv.query(i,m2), stc.query(i,m2));
			if(v1 > v2)
				r = m2;
			else
				l = m1;
		}
		int best = -1;
		for(; l <=r; ++l )
			best = max(best, min(100*stv.query(i,l), stc.query(i,l)));
		bestval[i] = best;
	}

	sort(all(bestval));

	ld ans = 0;

	ld sump= 0;
	ld bs = 1;
	REP(i,n){
		// probability that i is a minimum of k elements
		ld p=0;
		//p = ld(k)/ld(n) * binom(n-i-1, k-1) / binom(n-1, k-1);
		p = ld(k)/ld(n) * bs;
		//Log(i,p);
		sump+=p;
		ans += p * bestval[i];
		bs *= ld(n-k-i)/ld(n-1-i);
	}
	assert(abs(sump-1) < 1e-12);
	//Log("sump",sump);

	cout << fixed << setprecision(15) << ans << endl;

	return 0;
}


#pragma comment (linker, "/STACK:256000000")

#define _USE_MATH_DEFINES
#define _CRT_NO_DEPRECEATE
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <iomanip>
#include <fstream>
#include <cstdio>
#include <cstdlib>
#include <string>
#include <cstring>
#include <vector>
#include <utility>
#include <algorithm>
#include <functional>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <cmath>
#include <queue>
#include <memory.h>
#include <sstream>
#include <cassert>
#include <ctime>
#include <complex>
#include <random>

using namespace std;

typedef unsigned int uint32;
typedef long long int64;
typedef unsigned long long uint64;
typedef double ldouble;
typedef pair<int, int> pii;
typedef pair<int64, int64> pll;
typedef pair<pii, pii> piiii;

#define pb push_back
#define sq(x) ((x)*(x))
#define tmin(x,y,z) (min(min((x),(y)),(z)))
#define rand32() (((unsigned int)(rand()) << 16) | (unsigned int)(rand()))
#define rand64() (((unsigned int64)(rand32()) << 16) | (unsigned int64)(rand32()))
#define bit(mask, b) ((mask >> b) & 1)
#define biton(mask, bit) (mask | (((uint64)(1)) << bit))
#define bitoff(mask, bit) (mask & (~(((uint64)(1)) << bit)))
#define bitputon(mask, bit) (mask |= (((uint64)(1)) << bit))
#define bitputoff(mask, bit) (mask &= (~(((uint64)(1)) << bit)))
#define FAIL() (*((int*)(0)))++
#define INF ((int)(1e9) + 1337)
#define LINF ((int64)(1e18))
#define EPS (1e-7)
#define PI (3.1415926535897932384626433832795)
#define y1 yy1
#define y0 yy0
#define j0 jj0
//#define MOD 1000000007LL
#define HMOD 1234567891LL

//#define HMOD ((int64)(1e18) + 3LL)
//#ifdef _MY_DEBUG
//#define HMOD 1000000007
//#endif
#define MAX 2000000000
#define HBASE 1000003
mt19937 ggen;

int n, k;
int v[1000010];
int stv[21][1000010];
int c[1000010];
int stc[21][1000010];
int lg2[1000010];

void init()
{
    lg2[1] = 0;
    for (int i = 2; i < 1000010; i++)
        lg2[i] = lg2[i / 2] + 1;
}

void build_min(int st[][1000010], int a[])
{
    for (int i = 0; i < n; i++)
        st[0][i] = a[i];
    for (int pw = 1; pw <= 20; pw++)
    {
        for (int i = 0; i < n; i++)
        {
            st[pw][i] = st[pw - 1][i];
            int ni = i + (1 << (pw - 1));
            if (ni < n)
                st[pw][i] = min(st[pw][i], st[pw - 1][ni]);
        }
    }
}

inline int get_min(int st[][1000010], int l, int r)
{
    int len = r - l + 1;
    int lg = lg2[len];
    return min(st[lg][l], st[lg][r - (1 << lg) + 1]);
}

void build_max(int st[][1000010], int a[])
{
    for (int i = 0; i < n; i++)
        st[0][i] = a[i];
    for (int pw = 1; pw <= 20; pw++)
    {
        for (int i = 0; i < n; i++)
        {
            st[pw][i] = st[pw - 1][i];
            int ni = i + (1 << (pw - 1));
            if (ni < n)
                st[pw][i] = max(st[pw][i], st[pw - 1][ni]);
        }
    }
}

inline int get_max(int st[][1000010], int l, int r)
{
    int len = r - l + 1;
    int lg = lg2[len];
    return max(st[lg][l], st[lg][r - (1 << lg) + 1]);
}

inline int fun(int l, int r)
{
    return min(get_max(stv, l, r) * 100, get_min(stc, l, r));
}

int nr[1000010];
int nval[1000010];

inline int get_opt(int nl)
{
    int l = 1, r = n - nl, mid, res = 1;
    while (l <= r)
    {
        mid = (l + r) >> 1;
        if (get_max(stv, nl, nl + mid - 1) * 100 <= get_min(stc, nl, nl + mid - 1))
        {
            res = mid;
            l = mid + 1;
        }
        else
            r = mid - 1;
    }
    const int dt = 10;
    l = max(res - dt, 1);
    r = min(res + dt, n - nl);
    int resv = fun(nl, nl + res - 1);
    for (int i = l; i <= r; i++)
    {
        int tres = fun(nl, nl + i - 1);
        if (tres > resv)
        {
            res = i;
            resv = tres;
        }
    }
    return nl + res - 1;
}

void solve()
{
    init();
    scanf("%d%d", &n, &k);
    for (int i = 0; i < n; i++)
        scanf("%d", &v[i]);
    build_max(stv, v);
    for (int i = 0; i < n; i++)
        scanf("%d", &c[i]);
    build_min(stc, c);
    for (int i = 0; i < n; i++)
    {
        nr[i] = get_opt(i);
        nval[i] = fun(i, nr[i]);
        //printf("%d %d\n", nr[i], nval[i]);
    }
    sort(nval, nval + n);
    int ctr = 1;
    ldouble ans = 0;
    ldouble cur = (ldouble)k / (ldouble)(n - k + 1);
    for (int i = 1; i <= n; i++)
    {
        int z = n - i;
        cur = cur * ldouble(z - k + 2) / ldouble(z + 1);
        if (i == n || nval[i] != nval[i - 1])
        {
            ans += cur * (ldouble)ctr * (ldouble)nval[i - 1];
            ctr = 1;
        }
        else
            ctr++;
    }
    printf("%.9Lf", ans);
}

int main()
{
    //testgen2(10000, 1000, 23); return 0;
    ios_base::sync_with_stdio(false); cin.tie(0);
#ifdef _MY_DEBUG
    freopen("input.txt", "rt", stdin); freopen("output.txt", "wt", stdout);
#else
    //freopen(TASK ".in", "rt", stdin); freopen(TASK ".out", "wt", stdout);
#endif
    //stresstest(); return 0;
    srand(1313);
    ggen = mt19937(13);

    solve();

    return 0;
}


#define _USE_MATH_DEFINES
#define _CRT_NO_DEPRECEATE
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <iomanip>
#include <fstream>
#include <cstdio>
#include <cstdlib>
#include <string>
#include <cstring>
#include <vector>
#include <utility>
#include <algorithm>
#include <functional>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <cmath>
#include <queue>
#include <memory.h>
#include <sstream>
#include <cassert>
#include <ctime>
#include <complex>
#include <random>

using namespace std;

typedef unsigned int uint32;
typedef long long int64;
typedef unsigned long long uint64;
typedef long double ldouble;
typedef pair<int, int> pii;
typedef pair<int64, int64> pll;
typedef pair<pii, pii> piiii;

#define pb push_back
#define sq(x) ((x)*(x))
#define tmin(x,y,z) (min(min((x),(y)),(z)))
#define rand32() (((unsigned int)(rand()) << 16) | (unsigned int)(rand()))
#define rand64() (((unsigned int64)(rand32()) << 16) | (unsigned int64)(rand32()))
#define bit(mask, b) ((mask >> b) & 1)
#define biton(mask, bit) (mask | (((uint64)(1)) << bit))
#define bitoff(mask, bit) (mask & (~(((uint64)(1)) << bit)))
#define bitputon(mask, bit) (mask |= (((uint64)(1)) << bit))
#define bitputoff(mask, bit) (mask &= (~(((uint64)(1)) << bit)))
#define FAIL() (*((int*)(0)))++
#define INF ((int)(1e9) + 1337)
#define LINF ((int64)(1e18))
#define EPS (1e-7)
#define PI (3.1415926535897932384626433832795)
#define y1 yy1
#define y0 yy0
#define j0 jj0
//#define MOD 1000000007LL
#define HMOD 1234567891LL

//#define HMOD ((int64)(1e18) + 3LL)
//#ifdef _MY_DEBUG
//#define HMOD 1000000007
//#endif
#define MAX 2000000000
#define HBASE 1000003
mt19937 ggen;

int n, k;
int v[1000010];
int stv[21][1000010];
int c[1000010];
int stc[21][1000010];
int lg2[1000010];

void init()
{
    lg2[1] = 0;
    for (int i = 2; i < 1000010; i++)
        lg2[i] = lg2[i / 2] + 1;
}

void build_min(int st[][1000010], int a[])
{
    for (int i = 0; i < n; i++)
        st[0][i] = a[i];
    for (int pw = 1; pw <= 20; pw++)
    {
        for (int i = 0; i < n; i++)
        {
            st[pw][i] = st[pw - 1][i];
            int ni = i + (1 << (pw - 1));
            if (ni < n)
                st[pw][i] = min(st[pw][i], st[pw - 1][ni]);
        }
    }
}

inline int get_min(int st[][1000010], int l, int r)
{
    int len = r - l + 1;
    int lg = lg2[len];
    return min(st[lg][l], st[lg][r - (1 << lg) + 1]);
}

void build_max(int st[][1000010], int a[])
{
    for (int i = 0; i < n; i++)
        st[0][i] = a[i];
    for (int pw = 1; pw <= 20; pw++)
    {
        for (int i = 0; i < n; i++)
        {
            st[pw][i] = st[pw - 1][i];
            int ni = i + (1 << (pw - 1));
            if (ni < n)
                st[pw][i] = max(st[pw][i], st[pw - 1][ni]);
        }
    }
}

inline int get_max(int st[][1000010], int l, int r)
{
    int len = r - l + 1;
    int lg = lg2[len];
    return max(st[lg][l], st[lg][r - (1 << lg) + 1]);
}

inline int fun(int l, int r)
{
    return min(get_max(stv, l, r) * 100, get_min(stc, l, r));
}

int nr[1000010];
int nval[1000010];

inline int get_opt(int nl)
{
    int l = 1, r = n - nl, mid, res = 1;
    while (l <= r)
    {
        mid = (l + r) >> 1;
        if (get_max(stv, nl, nl + mid - 1) * 100 <= get_min(stc, nl, nl + mid - 1))
        {
            res = mid;
            l = mid + 1;
        }
        else
            r = mid - 1;
    }
    const int dt = 10;
    l = max(res - dt, 1);
    r = min(res + dt, n - nl);
    int resv = fun(nl, nl + res - 1);
    for (int i = l; i <= r; i++)
    {
        int tres = fun(nl, nl + i - 1);
        if (tres > resv)
        {
            res = i;
            resv = tres;
        }
    }
    return nl + res - 1;
}

void solve()
{
    init();
    scanf("%d%d", &n, &k);
    for (int i = 0; i < n; i++)
        scanf("%d", &v[i]);
    build_max(stv, v);
    for (int i = 0; i < n; i++)
        scanf("%d", &c[i]);
    build_min(stc, c);
    for (int i = 0; i < n; i++)
    {
        nr[i] = get_opt(i);
        nval[i] = fun(i, nr[i]);
        //printf("%d %d\n", nr[i], nval[i]);
    }
    sort(nval, nval + n);

    ldouble ans = 0;
    ldouble cur = (ldouble)k / (ldouble)(n - k + 1);
    for (int i = 0; i < n; i++)
    {
        int z = n - i - 1;
        cur = cur * ldouble(z - k + 2) / ldouble(z + 1);
        ans += cur * (ldouble)nval[i];
    }
    printf("%.9lf", (double)ans);
}

int main()
{
    //testgen2(10000, 1000, 23); return 0;
    ios_base::sync_with_stdio(false); cin.tie(0);
#ifdef _MY_DEBUG
    freopen("input.txt", "rt", stdin); freopen("output.txt", "wt", stdout);
#else
    //freopen(TASK ".in", "rt", stdin); freopen(TASK ".out", "wt", stdout);
#endif
    //stresstest(); return 0;
    srand(1313);
    ggen = mt19937(13);

    solve();

    return 0;
}


#pragma comment (linker, "/STACK:256000000")

#define _USE_MATH_DEFINES
#define _CRT_NO_DEPRECEATE
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <iomanip>
#include <fstream>
#include <cstdio>
#include <cstdlib>
#include <string>
#include <cstring>
#include <vector>
#include <utility>
#include <algorithm>
#include <functional>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <cmath>
#include <queue>
#include <memory.h>
#include <sstream>
#include <cassert>
#include <ctime>
#include <complex>
#include <random>

using namespace std;

typedef unsigned int uint32;
typedef long long int64;
typedef unsigned long long uint64;
typedef double ldouble;
typedef pair<int, int> pii;
typedef pair<int64, int64> pll;
typedef pair<pii, pii> piiii;

#define pb push_back
#define sq(x) ((x)*(x))
#define tmin(x,y,z) (min(min((x),(y)),(z)))
#define rand32() (((unsigned int)(rand()) << 16) | (unsigned int)(rand()))
#define rand64() (((unsigned int64)(rand32()) << 16) | (unsigned int64)(rand32()))
#define bit(mask, b) ((mask >> b) & 1)
#define biton(mask, bit) (mask | (((uint64)(1)) << bit))
#define bitoff(mask, bit) (mask & (~(((uint64)(1)) << bit)))
#define bitputon(mask, bit) (mask |= (((uint64)(1)) << bit))
#define bitputoff(mask, bit) (mask &= (~(((uint64)(1)) << bit)))
#define FAIL() (*((int*)(0)))++
#define INF ((int)(1e9) + 1337)
#define LINF ((int64)(1e18))
#define EPS (1e-7)
#define PI (3.1415926535897932384626433832795)
#define y1 yy1
#define y0 yy0
#define j0 jj0
//#define MOD 1000000007LL
#define HMOD 1234567891LL

//#define HMOD ((int64)(1e18) + 3LL)
//#ifdef _MY_DEBUG
//#define HMOD 1000000007
//#endif
#define MAX 2000000000
#define HBASE 1000003
mt19937 ggen;

int n, k;
int v[1000010];
int stv[21][1000010];
int c[1000010];
int stc[21][1000010];
int lg2[1000010];

void init()
{
    lg2[1] = 0;
    for (int i = 2; i < 1000010; i++)
        lg2[i] = lg2[i / 2] + 1;
}

void build_min(int st[][1000010], int a[])
{
    for (int i = 0; i < n; i++)
        st[0][i] = a[i];
    for (int pw = 1; pw <= 20; pw++)
    {
        for (int i = 0; i < n; i++)
        {
            st[pw][i] = st[pw - 1][i];
            int ni = i + (1 << (pw - 1));
            if (ni < n)
                st[pw][i] = min(st[pw][i], st[pw - 1][ni]);
        }
    }
}

inline int get_min(int st[][1000010], int l, int r)
{
    int len = r - l + 1;
    int lg = lg2[len];
    return min(st[lg][l], st[lg][r - (1 << lg) + 1]);
}

void build_max(int st[][1000010], int a[])
{
    for (int i = 0; i < n; i++)
        st[0][i] = a[i];
    for (int pw = 1; pw <= 20; pw++)
    {
        for (int i = 0; i < n; i++)
        {
            st[pw][i] = st[pw - 1][i];
            int ni = i + (1 << (pw - 1));
            if (ni < n)
                st[pw][i] = max(st[pw][i], st[pw - 1][ni]);
        }
    }
}

inline int get_max(int st[][1000010], int l, int r)
{
    int len = r - l + 1;
    int lg = lg2[len];
    return max(st[lg][l], st[lg][r - (1 << lg) + 1]);
}

inline int fun(int l, int r)
{
    return min(get_max(stv, l, r) * 100, get_min(stc, l, r));
}

int nr[1000010];
int nval[1000010];

inline int get_opt(int nl)
{
    int l = 1, r = n - nl, mid, res = 1;
    while (l <= r)
    {
        mid = (l + r) >> 1;
        if (get_max(stv, nl, nl + mid - 1) * 100 <= get_min(stc, nl, nl + mid - 1))
        {
            res = mid;
            l = mid + 1;
        }
        else
            r = mid - 1;
    }
    const int dt = n;
    l = max(res - dt, 1);
    r = min(res + dt, n - nl);
    int resv = fun(nl, nl + res - 1);
    for (int i = l; i <= r; i++)
    {
        int tres = fun(nl, nl + i - 1);
        if (tres > resv)
        {
            res = i;
            resv = tres;
        }
    }
    return nl + res - 1;
}

void solve()
{
    init();
    scanf("%d%d", &n, &k);
    for (int i = 0; i < n; i++)
        scanf("%d", &v[i]);
    build_max(stv, v);
    for (int i = 0; i < n; i++)
        scanf("%d", &c[i]);
    build_min(stc, c);
    for (int i = 0; i < n; i++)
    {
        nr[i] = get_opt(i);
        nval[i] = fun(i, nr[i]);
        //printf("%d %d\n", nr[i], nval[i]);
    }
    sort(nval, nval + n);
    int ctr = 1;
    ldouble ans = 0;
    ldouble cur = (ldouble)k / (ldouble)(n - k + 1);
    for (int i = 1; i <= n; i++)
    {
        int z = n - i;
        cur = cur / ldouble(z + 1) * ldouble(z - k + 2);
        if (i == n || nval[i] != nval[i - 1])
        {
            ans += cur * (ldouble)ctr * (ldouble)nval[i - 1];
            ctr = 1;
        }
        else
            ctr++;
    }
    printf("%.9Lf", ans);
}

int main()
{
    //testgen2(10000, 1000, 23); return 0;
    ios_base::sync_with_stdio(false); cin.tie(0);
#ifdef _MY_DEBUG
    freopen("input.txt", "rt", stdin); freopen("output.txt", "wt", stdout);
#else
    //freopen(TASK ".in", "rt", stdin); freopen(TASK ".out", "wt", stdout);
#endif
    //stresstest(); return 0;
    srand(1313);
    ggen = mt19937(13);

    solve();

    return 0;
}


#pragma comment (linker, "/STACK:256000000")

#define _USE_MATH_DEFINES
#define _CRT_NO_DEPRECEATE
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <iomanip>
#include <fstream>
#include <cstdio>
#include <cstdlib>
#include <string>
#include <cstring>
#include <vector>
#include <utility>
#include <algorithm>
#include <functional>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <cmath>
#include <queue>
#include <memory.h>
#include <sstream>
#include <cassert>
#include <ctime>
#include <complex>
#include <random>

using namespace std;

typedef unsigned int uint32;
typedef long long int64;
typedef unsigned long long uint64;
typedef double ldouble;
typedef pair<int, int> pii;
typedef pair<int64, int64> pll;
typedef pair<pii, pii> piiii;

#define pb push_back
#define sq(x) ((x)*(x))
#define tmin(x,y,z) (min(min((x),(y)),(z)))
#define rand32() (((unsigned int)(rand()) << 16) | (unsigned int)(rand()))
#define rand64() (((unsigned int64)(rand32()) << 16) | (unsigned int64)(rand32()))
#define bit(mask, b) ((mask >> b) & 1)
#define biton(mask, bit) (mask | (((uint64)(1)) << bit))
#define bitoff(mask, bit) (mask & (~(((uint64)(1)) << bit)))
#define bitputon(mask, bit) (mask |= (((uint64)(1)) << bit))
#define bitputoff(mask, bit) (mask &= (~(((uint64)(1)) << bit)))
#define FAIL() (*((int*)(0)))++
#define INF ((int)(1e9) + 1337)
#define LINF ((int64)(1e18))
#define EPS (1e-7)
#define PI (3.1415926535897932384626433832795)
#define y1 yy1
#define y0 yy0
#define j0 jj0
//#define MOD 1000000007LL
#define HMOD 1234567891LL

//#define HMOD ((int64)(1e18) + 3LL)
//#ifdef _MY_DEBUG
//#define HMOD 1000000007
//#endif
#define MAX 2000000000
#define HBASE 1000003
mt19937 ggen;

int n, k;
int v[1000010];
int stv[21][1000010];
int c[1000010];
int stc[21][1000010];
int lg2[1000010];

void init()
{
    lg2[1] = 0;
    for (int i = 2; i < 1000010; i++)
        lg2[i] = lg2[i / 2] + 1;
}

void build_min(int st[][1000010], int a[])
{
    for (int i = 0; i < n; i++)
        st[0][i] = a[i];
    for (int pw = 1; pw <= 20; pw++)
    {
        for (int i = 0; i < n; i++)
        {
            st[pw][i] = st[pw - 1][i];
            int ni = i + (1 << (pw - 1));
            if (ni < n)
                st[pw][i] = min(st[pw][i], st[pw - 1][ni]);
        }
    }
}

inline int get_min(int st[][1000010], int l, int r)
{
    int len = r - l + 1;
    int lg = lg2[len];
    return min(st[lg][l], st[lg][r - (1 << lg) + 1]);
}

void build_max(int st[][1000010], int a[])
{
    for (int i = 0; i < n; i++)
        st[0][i] = a[i];
    for (int pw = 1; pw <= 20; pw++)
    {
        for (int i = 0; i < n; i++)
        {
            st[pw][i] = st[pw - 1][i];
            int ni = i + (1 << (pw - 1));
            if (ni < n)
                st[pw][i] = max(st[pw][i], st[pw - 1][ni]);
        }
    }
}

inline int get_max(int st[][1000010], int l, int r)
{
    int len = r - l + 1;
    int lg = lg2[len];
    return max(st[lg][l], st[lg][r - (1 << lg) + 1]);
}

inline int fun(int l, int r)
{
    return min(get_max(stv, l, r) * 100, get_min(stc, l, r));
}

int nr[1000010];
int nval[1000010];

inline int get_opt(int nl)
{
    int l = 1, r = n - nl, mid, res = 1;
    while (l <= r)
    {
        mid = (l + r) >> 1;
        if (get_max(stv, nl, nl + mid - 1) * 100 <= get_min(stc, nl, nl + mid - 1))
        {
            res = mid;
            l = mid + 1;
        }
        else
            r = mid - 1;
    }
    const int dt = 10;
    l = max(res - dt, 1);
    r = min(res + dt, n - nl);
    int resv = fun(nl, nl + res - 1);
    for (int i = l; i <= r; i++)
    {
        int tres = fun(nl, nl + i - 1);
        if (tres > resv)
        {
            res = i;
            resv = tres;
        }
    }
    return nl + res - 1;
}

void solve()
{
    init();
    scanf("%d%d", &n, &k);
    for (int i = 0; i < n; i++)
        scanf("%d", &v[i]);
    build_max(stv, v);
    for (int i = 0; i < n; i++)
        scanf("%d", &c[i]);
    build_min(stc, c);
    for (int i = 0; i < n; i++)
    {
        nr[i] = get_opt(i);
        nval[i] = fun(i, nr[i]);
        //printf("%d %d\n", nr[i], nval[i]);
    }
    sort(nval, nval + n);
    int ctr = 1;
    ldouble ans = 0;
    ldouble cur = k / (n - k + 1);
    for (int i = 1; i <= n; i++)
    {
        int z = n - i;
        cur = cur / ldouble(z + 1) * ldouble(z - k + 2);
        if (i == n || nval[i] != nval[i - 1])
        {
            int z = n - i;
            ans += cur * ctr * nval[i - 1];
            ctr = 1;
        }
        else
            ctr++;
    }
    printf("%.9Lf", ans);
}

int main()
{
    //testgen2(10000, 1000, 23); return 0;
    ios_base::sync_with_stdio(false); cin.tie(0);
#ifdef _MY_DEBUG
    freopen("input.txt", "rt", stdin); freopen("output.txt", "wt", stdout);
#else
    //freopen(TASK ".in", "rt", stdin); freopen(TASK ".out", "wt", stdout);
#endif
    //stresstest(); return 0;
    srand(1313);
    ggen = mt19937(13);

    solve();

    return 0;
}


#pragma comment (linker, "/STACK:256000000")

#define _USE_MATH_DEFINES
#define _CRT_NO_DEPRECEATE
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <iomanip>
#include <fstream>
#include <cstdio>
#include <cstdlib>
#include <string>
#include <cstring>
#include <vector>
#include <utility>
#include <algorithm>
#include <functional>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <cmath>
#include <queue>
#include <memory.h>
#include <sstream>
#include <cassert>
#include <ctime>
#include <complex>
#include <random>

using namespace std;

typedef unsigned int uint32;
typedef long long int64;
typedef unsigned long long uint64;
typedef double ldouble;
typedef pair<int, int> pii;
typedef pair<int64, int64> pll;
typedef pair<pii, pii> piiii;

#define pb push_back
#define sq(x) ((x)*(x))
#define tmin(x,y,z) (min(min((x),(y)),(z)))
#define rand32() (((unsigned int)(rand()) << 16) | (unsigned int)(rand()))
#define rand64() (((unsigned int64)(rand32()) << 16) | (unsigned int64)(rand32()))
#define bit(mask, b) ((mask >> b) & 1)
#define biton(mask, bit) (mask | (((uint64)(1)) << bit))
#define bitoff(mask, bit) (mask & (~(((uint64)(1)) << bit)))
#define bitputon(mask, bit) (mask |= (((uint64)(1)) << bit))
#define bitputoff(mask, bit) (mask &= (~(((uint64)(1)) << bit)))
#define FAIL() (*((int*)(0)))++
#define INF ((int)(1e9) + 1337)
#define LINF ((int64)(1e18))
#define EPS (1e-7)
#define PI (3.1415926535897932384626433832795)
#define y1 yy1
#define y0 yy0
#define j0 jj0
//#define MOD 1000000007LL
#define HMOD 1234567891LL

//#define HMOD ((int64)(1e18) + 3LL)
//#ifdef _MY_DEBUG
//#define HMOD 1000000007
//#endif
#define MAX 2000000000
#define HBASE 1000003
mt19937 ggen;

int n, k;
int v[1000010];
int stv[21][1000010];
int c[1000010];
int stc[21][1000010];
int lg2[1000010];

void init()
{
    lg2[1] = 0;
    for (int i = 2; i < 1000010; i++)
        lg2[i] = lg2[i / 2] + 1;
}

void build_min(int st[][1000010], int a[])
{
    for (int i = 0; i < n; i++)
        st[0][i] = a[i];
    for (int pw = 1; pw <= 20; pw++)
    {
        for (int i = 0; i < n; i++)
        {
            st[pw][i] = st[pw - 1][i];
            int ni = i + (1 << (pw - 1));
            if (ni < n)
                st[pw][i] = min(st[pw][i], st[pw - 1][ni]);
        }
    }
}

inline int get_min(int st[][1000010], int l, int r)
{
    int len = r - l + 1;
    int lg = lg2[len];
    return min(st[lg][l], st[lg][r - (1 << lg) + 1]);
}

void build_max(int st[][1000010], int a[])
{
    for (int i = 0; i < n; i++)
        st[0][i] = a[i];
    for (int pw = 1; pw <= 20; pw++)
    {
        for (int i = 0; i < n; i++)
        {
            st[pw][i] = st[pw - 1][i];
            int ni = i + (1 << (pw - 1));
            if (ni < n)
                st[pw][i] = max(st[pw][i], st[pw - 1][ni]);
        }
    }
}

inline int get_max(int st[][1000010], int l, int r)
{
    int len = r - l + 1;
    int lg = lg2[len];
    return max(st[lg][l], st[lg][r - (1 << lg) + 1]);
}

inline int fun(int l, int r)
{
    return min(get_max(stv, l, r) * 100, get_min(stc, l, r));
}

int nr[1000010];
int nval[1000010];

inline int get_opt(int nl)
{
    int l = 1, r = n - nl, mid, res = 1;
    while (l <= r)
    {
        mid = (l + r) >> 1;
        if (get_max(stv, nl, nl + mid - 1) * 100 <= get_min(stc, nl, nl + mid - 1))
        {
            res = mid;
            l = mid + 1;
        }
        else
            r = mid - 1;
    }
    const int dt = 10;
    l = max(res - dt, 1);
    r = min(res + dt, n - nl);
    int resv = fun(nl, nl + res - 1);
    for (int i = l; i <= r; i++)
    {
        int tres = fun(nl, nl + i - 1);
        if (tres > resv)
        {
            res = i;
            resv = tres;
        }
    }
    return nl + res - 1;
}

void solve()
{
    init();
    scanf("%d%d", &n, &k);
    for (int i = 0; i < n; i++)
        scanf("%d", &v[i]);
    build_max(stv, v);
    for (int i = 0; i < n; i++)
        scanf("%d", &c[i]);
    build_min(stc, c);
    for (int i = 0; i < n; i++)
    {
        nr[i] = get_opt(i);
        nval[i] = fun(i, nr[i]);
        //printf("%d %d\n", nr[i], nval[i]);
    }
    sort(nval, nval + n);
    int ctr = 1;
    ldouble ans = 0;
    ldouble cur = (ldouble)k / (ldouble)(n - k + 1);
    for (int i = 1; i <= n; i++)
    {
        int z = n - i;
        cur = cur / ldouble(z + 1) * ldouble(z - k + 2);
        if (i == n || nval[i] != nval[i - 1])
        {
            ans += cur * (ldouble)ctr * (ldouble)nval[i - 1];
            ctr = 1;
        }
        else
            ctr++;
    }
    printf("%.9Lf", ans);
}

int main()
{
    //testgen2(10000, 1000, 23); return 0;
    ios_base::sync_with_stdio(false); cin.tie(0);
#ifdef _MY_DEBUG
    freopen("input.txt", "rt", stdin); freopen("output.txt", "wt", stdout);
#else
    //freopen(TASK ".in", "rt", stdin); freopen(TASK ".out", "wt", stdout);
#endif
    //stresstest(); return 0;
    srand(1313);
    ggen = mt19937(13);

    solve();

    return 0;
}


#pragma comment (linker, "/STACK:256000000")

#define _USE_MATH_DEFINES
#define _CRT_NO_DEPRECEATE
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <iomanip>
#include <fstream>
#include <cstdio>
#include <cstdlib>
#include <string>
#include <cstring>
#include <vector>
#include <utility>
#include <algorithm>
#include <functional>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <cmath>
#include <queue>
#include <memory.h>
#include <sstream>
#include <cassert>
#include <ctime>
#include <complex>
#include <random>

using namespace std;

typedef unsigned int uint32;
typedef long long int64;
typedef unsigned long long uint64;
typedef long double ldouble;
typedef pair<int, int> pii;
typedef pair<int64, int64> pll;
typedef pair<pii, pii> piiii;

#define pb push_back
#define sq(x) ((x)*(x))
#define tmin(x,y,z) (min(min((x),(y)),(z)))
#define rand32() (((unsigned int)(rand()) << 16) | (unsigned int)(rand()))
#define rand64() (((unsigned int64)(rand32()) << 16) | (unsigned int64)(rand32()))
#define bit(mask, b) ((mask >> b) & 1)
#define biton(mask, bit) (mask | (((uint64)(1)) << bit))
#define bitoff(mask, bit) (mask & (~(((uint64)(1)) << bit)))
#define bitputon(mask, bit) (mask |= (((uint64)(1)) << bit))
#define bitputoff(mask, bit) (mask &= (~(((uint64)(1)) << bit)))
#define FAIL() (*((int*)(0)))++
#define INF ((int)(1e9) + 1337)
#define LINF ((int64)(1e18))
#define EPS (1e-7)
#define PI (3.1415926535897932384626433832795)
#define y1 yy1
#define y0 yy0
#define j0 jj0
//#define MOD 1000000007LL
#define HMOD 1234567891LL

//#define HMOD ((int64)(1e18) + 3LL)
//#ifdef _MY_DEBUG
//#define HMOD 1000000007
//#endif
#define MAX 2000000000
#define HBASE 1000003
mt19937 ggen;

int n, k;
int v[1000010];
int stv[21][1000010];
int c[1000010];
int stc[21][1000010];
int lg2[1000010];

void init()
{
    lg2[1] = 0;
    for (int i = 2; i < 1000010; i++)
        lg2[i] = lg2[i / 2] + 1;
}

void build_min(int st[][1000010], int a[])
{
    for (int i = 0; i < n; i++)
        st[0][i] = a[i];
    for (int pw = 1; pw <= 20; pw++)
    {
        for (int i = 0; i < n; i++)
        {
            st[pw][i] = st[pw - 1][i];
            int ni = i + (1 << (pw - 1));
            if (ni < n)
                st[pw][i] = min(st[pw][i], st[pw - 1][ni]);
        }
    }
}

inline int get_min(int st[][1000010], int l, int r)
{
    int len = r - l + 1;
    int lg = lg2[len];
    return min(st[lg][l], st[lg][r - (1 << lg) + 1]);
}

void build_max(int st[][1000010], int a[])
{
    for (int i = 0; i < n; i++)
        st[0][i] = a[i];
    for (int pw = 1; pw <= 20; pw++)
    {
        for (int i = 0; i < n; i++)
        {
            st[pw][i] = st[pw - 1][i];
            int ni = i + (1 << (pw - 1));
            if (ni < n)
                st[pw][i] = max(st[pw][i], st[pw - 1][ni]);
        }
    }
}

inline int get_max(int st[][1000010], int l, int r)
{
    int len = r - l + 1;
    int lg = lg2[len];
    return max(st[lg][l], st[lg][r - (1 << lg) + 1]);
}

inline int fun(int l, int r)
{
    return min(get_max(stv, l, r) * 100, get_min(stc, l, r));
}

int nr[1000010];
int nval[1000010];

inline int get_opt(int nl)
{
    int l = 1, r = n - nl, mid, res = 1;
    while (l <= r)
    {
        mid = (l + r) >> 1;
        if (get_max(stv, nl, nl + mid - 1) * 100 <= get_min(stc, nl, nl + mid - 1))
        {
            res = mid;
            l = mid + 1;
        }
        else
            r = mid - 1;
    }
    const int dt = 10;
    l = max(res - dt, 1);
    r = min(res + dt, n - nl);
    int resv = fun(nl, nl + res - 1);
    for (int i = l; i <= r; i++)
    {
        int tres = fun(nl, nl + i - 1);
        if (tres > resv)
        {
            res = i;
            resv = tres;
        }
    }
    return nl + res - 1;
}

void solve()
{
    init();
    scanf("%d%d", &n, &k);
    for (int i = 0; i < n; i++)
        scanf("%d", &v[i]);
    build_max(stv, v);
    for (int i = 0; i < n; i++)
        scanf("%d", &c[i]);
    build_min(stc, c);
    for (int i = 0; i < n; i++)
    {
        nr[i] = get_opt(i);
        nval[i] = fun(i, nr[i]);
        //printf("%d %d\n", nr[i], nval[i]);
    }
    sort(nval, nval + n);

    ldouble ans = 0;
    ldouble cur = (ldouble)k / (ldouble)(n - k + 1);
    for (int i = 0; i < n; i++)
    {
        int z = n - i - 1;
        cur = cur * ldouble(z - k + 2) / ldouble(z + 1);
        ans += cur * (ldouble)nval[i];
    }
    printf("%.9Lf", ans);
}

int main()
{
    //testgen2(10000, 1000, 23); return 0;
    ios_base::sync_with_stdio(false); cin.tie(0);
#ifdef _MY_DEBUG
    freopen("input.txt", "rt", stdin); freopen("output.txt", "wt", stdout);
#else
    //freopen(TASK ".in", "rt", stdin); freopen(TASK ".out", "wt", stdout);
#endif
    //stresstest(); return 0;
    srand(1313);
    ggen = mt19937(13);

    solve();

    return 0;
}


#pragma comment (linker, "/STACK:256000000")

#define _USE_MATH_DEFINES
#define _CRT_NO_DEPRECEATE
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <iomanip>
#include <fstream>
#include <cstdio>
#include <cstdlib>
#include <string>
#include <cstring>
#include <vector>
#include <utility>
#include <algorithm>
#include <functional>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <cmath>
#include <queue>
#include <memory.h>
#include <sstream>
#include <cassert>
#include <ctime>
#include <complex>
#include <random>

using namespace std;

typedef unsigned int uint32;
typedef long long int64;
typedef unsigned long long uint64;
typedef double ldouble;
typedef pair<int, int> pii;
typedef pair<int64, int64> pll;
typedef pair<pii, pii> piiii;

#define pb push_back
#define sq(x) ((x)*(x))
#define tmin(x,y,z) (min(min((x),(y)),(z)))
#define rand32() (((unsigned int)(rand()) << 16) | (unsigned int)(rand()))
#define rand64() (((unsigned int64)(rand32()) << 16) | (unsigned int64)(rand32()))
#define bit(mask, b) ((mask >> b) & 1)
#define biton(mask, bit) (mask | (((uint64)(1)) << bit))
#define bitoff(mask, bit) (mask & (~(((uint64)(1)) << bit)))
#define bitputon(mask, bit) (mask |= (((uint64)(1)) << bit))
#define bitputoff(mask, bit) (mask &= (~(((uint64)(1)) << bit)))
#define FAIL() (*((int*)(0)))++
#define INF ((int)(1e9) + 1337)
#define LINF ((int64)(1e18))
#define EPS (1e-7)
#define PI (3.1415926535897932384626433832795)
#define y1 yy1
#define y0 yy0
#define j0 jj0
//#define MOD 1000000007LL
#define HMOD 1234567891LL

//#define HMOD ((int64)(1e18) + 3LL)
//#ifdef _MY_DEBUG
//#define HMOD 1000000007
//#endif
#define MAX 2000000000
#define HBASE 1000003
mt19937 ggen;

int n, k;
int v[1000010];
int stv[21][1000010];
int c[1000010];
int stc[21][1000010];
int lg2[1000010];

void init()
{
    lg2[1] = 0;
    for (int i = 2; i < 1000010; i++)
        lg2[i] = lg2[i / 2] + 1;
}

void build_min(int st[][1000010], int a[])
{
    for (int i = 0; i < n; i++)
        st[0][i] = a[i];
    for (int pw = 1; pw <= 20; pw++)
    {
        for (int i = 0; i < n; i++)
        {
            st[pw][i] = st[pw - 1][i];
            int ni = i + (1 << (pw - 1));
            if (ni < n)
                st[pw][i] = min(st[pw][i], st[pw - 1][ni]);
        }
    }
}

inline int get_min(int st[][1000010], int l, int r)
{
    int len = r - l + 1;
    int lg = lg2[len];
    return min(st[lg][l], st[lg][r - (1 << lg) + 1]);
}

void build_max(int st[][1000010], int a[])
{
    for (int i = 0; i < n; i++)
        st[0][i] = a[i];
    for (int pw = 1; pw <= 20; pw++)
    {
        for (int i = 0; i < n; i++)
        {
            st[pw][i] = st[pw - 1][i];
            int ni = i + (1 << (pw - 1));
            if (ni < n)
                st[pw][i] = max(st[pw][i], st[pw - 1][ni]);
        }
    }
}

inline int get_max(int st[][1000010], int l, int r)
{
    int len = r - l + 1;
    int lg = lg2[len];
    return max(st[lg][l], st[lg][r - (1 << lg) + 1]);
}

inline int fun(int l, int r)
{
    return min(get_max(stv, l, r) * 100, get_min(stc, l, r));
}

int nr[1000010];
int nval[1000010];

inline int get_opt(int nl)
{
    int l = 1, r = n - nl, mid, res = 1;
    while (l <= r)
    {
        mid = (l + r) >> 1;
        if (get_max(stv, nl, nl + mid - 1) * 100 <= get_min(stc, nl, nl + mid - 1))
        {
            res = mid;
            l = mid + 1;
        }
        else
            r = mid - 1;
    }
    const int dt = 10;
    l = max(res - dt, 1);
    r = min(res + dt, n - nl);
    int resv = fun(nl, nl + res - 1);
    for (int i = l; i <= r; i++)
    {
        int tres = fun(nl, nl + i - 1);
        if (tres > resv)
        {
            res = i;
            resv = tres;
        }
    }
    return nl + res - 1;
}

void solve()
{
    init();
    scanf("%d%d", &n, &k);
    for (int i = 0; i < n; i++)
        scanf("%d", &v[i]);
    build_max(stv, v);
    for (int i = 0; i < n; i++)
        scanf("%d", &c[i]);
    build_min(stc, c);
    for (int i = 0; i < n; i++)
    {
        nr[i] = get_opt(i);
        nval[i] = fun(i, nr[i]);
        //printf("%d %d\n", nr[i], nval[i]);
    }
    sort(nval, nval + n);
    int ctr = 1;
    ldouble ans = 0;
    ldouble cur = k / (n - k + 1);
    for (int i = 1; i <= n; i++)
    {
        int z = n - i;
        cur = cur / ldouble(z + 1) * ldouble(z - k + 2);
        if (i == n || nval[i] != nval[i - 1])
        {
            int z = n - i;
            ans += cur * ctr * nval[i - 1];
            ctr = 1;
        }
        else
            ctr++;
    }
    cout.precision(10);
    cout << fixed << ans;
}

int main()
{
    //testgen2(10000, 1000, 23); return 0;
    ios_base::sync_with_stdio(false); cin.tie(0);
#ifdef _MY_DEBUG
    freopen("input.txt", "rt", stdin); freopen("output.txt", "wt", stdout);
#else
    //freopen(TASK ".in", "rt", stdin); freopen(TASK ".out", "wt", stdout);
#endif
    //stresstest(); return 0;
    srand(1313);
    ggen = mt19937(13);

    solve();

    return 0;
}


#pragma comment (linker, "/STACK:256000000")

#define _USE_MATH_DEFINES
#define _CRT_NO_DEPRECEATE
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <iomanip>
#include <fstream>
#include <cstdio>
#include <cstdlib>
#include <string>
#include <cstring>
#include <vector>
#include <utility>
#include <algorithm>
#include <functional>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <cmath>
#include <queue>
#include <memory.h>
#include <sstream>
#include <cassert>
#include <ctime>
#include <complex>
#include <random>

using namespace std;

typedef unsigned int uint32;
typedef long long int64;
typedef unsigned long long uint64;
typedef double ldouble;
typedef pair<int, int> pii;
typedef pair<int64, int64> pll;
typedef pair<pii, pii> piiii;

#define pb push_back
#define sq(x) ((x)*(x))
#define tmin(x,y,z) (min(min((x),(y)),(z)))
#define rand32() (((unsigned int)(rand()) << 16) | (unsigned int)(rand()))
#define rand64() (((unsigned int64)(rand32()) << 16) | (unsigned int64)(rand32()))
#define bit(mask, b) ((mask >> b) & 1)
#define biton(mask, bit) (mask | (((uint64)(1)) << bit))
#define bitoff(mask, bit) (mask & (~(((uint64)(1)) << bit)))
#define bitputon(mask, bit) (mask |= (((uint64)(1)) << bit))
#define bitputoff(mask, bit) (mask &= (~(((uint64)(1)) << bit)))
#define FAIL() (*((int*)(0)))++
#define INF ((int)(1e9) + 1337)
#define LINF ((int64)(1e18))
#define EPS (1e-7)
#define PI (3.1415926535897932384626433832795)
#define y1 yy1
#define y0 yy0
#define j0 jj0
//#define MOD 1000000007LL
#define HMOD 1234567891LL

//#define HMOD ((int64)(1e18) + 3LL)
//#ifdef _MY_DEBUG
//#define HMOD 1000000007
//#endif
#define MAX 2000000000
#define HBASE 1000003
mt19937 ggen;

int n, k;
int v[1000010];
int stv[21][1000010];
int c[1000010];
int stc[21][1000010];
int lg2[1000010];

void init()
{
    lg2[1] = 0;
    for (int i = 2; i < 1000010; i++)
        lg2[i] = lg2[i / 2] + 1;
}

void build_min(int st[][1000010], int a[])
{
    for (int i = 0; i < n; i++)
        st[0][i] = a[i];
    for (int pw = 1; pw <= 20; pw++)
    {
        for (int i = 0; i < n; i++)
        {
            st[pw][i] = st[pw - 1][i];
            int ni = i + (1 << (pw - 1));
            if (ni < n)
                st[pw][i] = min(st[pw][i], st[pw - 1][ni]);
        }
    }
}

inline int get_min(int st[][1000010], int l, int r)
{
    int len = r - l + 1;
    int lg = lg2[len];
    return min(st[lg][l], st[lg][r - (1 << lg) + 1]);
}

void build_max(int st[][1000010], int a[])
{
    for (int i = 0; i < n; i++)
        st[0][i] = a[i];
    for (int pw = 1; pw <= 20; pw++)
    {
        for (int i = 0; i < n; i++)
        {
            st[pw][i] = st[pw - 1][i];
            int ni = i + (1 << (pw - 1));
            if (ni < n)
                st[pw][i] = max(st[pw][i], st[pw - 1][ni]);
        }
    }
}

inline int get_max(int st[][1000010], int l, int r)
{
    int len = r - l + 1;
    int lg = lg2[len];
    return max(st[lg][l], st[lg][r - (1 << lg) + 1]);
}

inline int fun(int l, int r)
{
    return min(get_max(stv, l, r) * 100, get_min(stc, l, r));
}

int nr[1000010];
int nval[1000010];

inline int get_opt(int nl)
{
    int l = 1, r = n - nl, mid, res = 1;
    while (l <= r)
    {
        mid = (l + r) >> 1;
        if (get_max(stv, nl, nl + mid - 1) * 100 <= get_min(stc, nl, nl + mid - 1))
        {
            res = mid;
            l = mid + 1;
        }
        else
            r = mid - 1;
    }
    const int dt = 20;
    l = max(res - dt, 1);
    r = min(res + dt, n - nl);
    int resv = fun(nl, nl + res - 1);
    for (int i = l; i <= r; i++)
    {
        int tres = fun(nl, nl + i - 1);
        if (tres > resv)
        {
            res = i;
            resv = tres;
        }
    }
    return nl + res - 1;
}

void solve()
{
    init();
    scanf("%d%d", &n, &k);
    for (int i = 0; i < n; i++)
        scanf("%d", &v[i]);
    build_max(stv, v);
    for (int i = 0; i < n; i++)
        scanf("%d", &c[i]);
    build_min(stc, c);
    for (int i = 0; i < n; i++)
    {
        nr[i] = get_opt(i);
        nval[i] = fun(i, nr[i]);
        //printf("%d %d\n", nr[i], nval[i]);
    }
    sort(nval, nval + n);
    int ctr = 1;
    ldouble ans = 0;
    ldouble cur = (ldouble)k / (ldouble)(n - k + 1);
    for (int i = 1; i <= n; i++)
    {
        int z = n - i;
        cur = cur / ldouble(z + 1) * ldouble(z - k + 2);
        if (i == n || nval[i] != nval[i - 1])
        {
            ans += cur * (ldouble)ctr * (ldouble)nval[i - 1];
            ctr = 1;
        }
        else
            ctr++;
    }
    printf("%.9Lf", ans);
}

int main()
{
    //testgen2(10000, 1000, 23); return 0;
    ios_base::sync_with_stdio(false); cin.tie(0);
#ifdef _MY_DEBUG
    freopen("input.txt", "rt", stdin); freopen("output.txt", "wt", stdout);
#else
    //freopen(TASK ".in", "rt", stdin); freopen(TASK ".out", "wt", stdout);
#endif
    //stresstest(); return 0;
    srand(1313);
    ggen = mt19937(13);

    solve();

    return 0;
}


#pragma comment (linker, "/STACK:256000000")

#define _USE_MATH_DEFINES
#define _CRT_NO_DEPRECEATE
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <iomanip>
#include <fstream>
#include <cstdio>
#include <cstdlib>
#include <string>
#include <cstring>
#include <vector>
#include <utility>
#include <algorithm>
#include <functional>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <cmath>
#include <queue>
#include <memory.h>
#include <sstream>
#include <cassert>
#include <ctime>
#include <complex>
#include <random>

using namespace std;

typedef unsigned int uint32;
typedef long long int64;
typedef unsigned long long uint64;
typedef double ldouble;
typedef pair<int, int> pii;
typedef pair<int64, int64> pll;
typedef pair<pii, pii> piiii;

#define pb push_back
#define sq(x) ((x)*(x))
#define tmin(x,y,z) (min(min((x),(y)),(z)))
#define rand32() (((unsigned int)(rand()) << 16) | (unsigned int)(rand()))
#define rand64() (((unsigned int64)(rand32()) << 16) | (unsigned int64)(rand32()))
#define bit(mask, b) ((mask >> b) & 1)
#define biton(mask, bit) (mask | (((uint64)(1)) << bit))
#define bitoff(mask, bit) (mask & (~(((uint64)(1)) << bit)))
#define bitputon(mask, bit) (mask |= (((uint64)(1)) << bit))
#define bitputoff(mask, bit) (mask &= (~(((uint64)(1)) << bit)))
#define FAIL() (*((int*)(0)))++
#define INF ((int)(1e9) + 1337)
#define LINF ((int64)(1e18))
#define EPS (1e-7)
#define PI (3.1415926535897932384626433832795)
#define y1 yy1
#define y0 yy0
#define j0 jj0
//#define MOD 1000000007LL
#define HMOD 1234567891LL

//#define HMOD ((int64)(1e18) + 3LL)
//#ifdef _MY_DEBUG
//#define HMOD 1000000007
//#endif
#define MAX 2000000000
#define HBASE 1000003
mt19937 ggen;

int n, k;
int v[1000010];
int stv[21][1000010];
int c[1000010];
int stc[21][1000010];
int lg2[1000010];

void init()
{
    lg2[1] = 0;
    for (int i = 2; i < 1000010; i++)
        lg2[i] = lg2[i / 2] + 1;
}

void build_min(int st[][1000010], int a[])
{
    for (int i = 0; i < n; i++)
        st[0][i] = a[i];
    for (int pw = 1; pw <= 20; pw++)
    {
        for (int i = 0; i < n; i++)
        {
            st[pw][i] = st[pw - 1][i];
            int ni = i + (1 << (pw - 1));
            if (ni < n)
                st[pw][i] = min(st[pw][i], st[pw - 1][ni]);
        }
    }
}

inline int get_min(int st[][1000010], int l, int r)
{
    int len = r - l + 1;
    int lg = lg2[len];
    return min(st[lg][l], st[lg][r - (1 << lg) + 1]);
}

void build_max(int st[][1000010], int a[])
{
    for (int i = 0; i < n; i++)
        st[0][i] = a[i];
    for (int pw = 1; pw <= 20; pw++)
    {
        for (int i = 0; i < n; i++)
        {
            st[pw][i] = st[pw - 1][i];
            int ni = i + (1 << (pw - 1));
            if (ni < n)
                st[pw][i] = max(st[pw][i], st[pw - 1][ni]);
        }
    }
}

inline int get_max(int st[][1000010], int l, int r)
{
    int len = r - l + 1;
    int lg = lg2[len];
    return max(st[lg][l], st[lg][r - (1 << lg) + 1]);
}

inline int fun(int l, int r)
{
    return min(get_max(stv, l, r) * 100, get_min(stc, l, r));
}

int nr[1000010];
int nval[1000010];

inline int get_opt(int nl)
{
    int l = 1, r = n - nl, mid, res = 1;
    while (l <= r)
    {
        mid = (l + r) >> 1;
        if (get_max(stv, nl, nl + mid - 1) * 100 <= get_min(stc, nl, nl + mid - 1))
        {
            res = mid;
            l = mid + 1;
        }
        else
            r = mid - 1;
    }
    const int dt = 10;
    l = max(res - dt, 1);
    r = min(res + dt, n - nl);
    int resv = fun(nl, nl + res - 1);
    for (int i = l; i <= r; i++)
    {
        int tres = fun(nl, nl + i - 1);
        if (tres > resv)
        {
            res = i;
            resv = tres;
        }
    }
    return nl + res - 1;
}

void solve()
{
    init();
    scanf("%d%d", &n, &k);
    for (int i = 0; i < n; i++)
        scanf("%d", &v[i]);
    build_max(stv, v);
    for (int i = 0; i < n; i++)
        scanf("%d", &c[i]);
    build_min(stc, c);
    for (int i = 0; i < n; i++)
    {
        nr[i] = get_opt(i);
        nval[i] = fun(i, nr[i]);
        //printf("%d %d\n", nr[i], nval[i]);
    }
    sort(nval, nval + n);
    int ctr = 1;
    ldouble ans = 0;
    ldouble cur = (ldouble)k / (ldouble)(n - k + 1);
    for (int i = 0; i < n; i++)
    {
        int z = n - i - 1;
        cur = cur * ldouble(z - k + 2) / ldouble(z + 1);
        ans += cur * (ldouble)nval[i];
    }
    printf("%.9Lf", ans);
}

int main()
{
    //testgen2(10000, 1000, 23); return 0;
    ios_base::sync_with_stdio(false); cin.tie(0);
#ifdef _MY_DEBUG
    freopen("input.txt", "rt", stdin); freopen("output.txt", "wt", stdout);
#else
    //freopen(TASK ".in", "rt", stdin); freopen(TASK ".out", "wt", stdout);
#endif
    //stresstest(); return 0;
    srand(1313);
    ggen = mt19937(13);

    solve();

    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define MAXN 1000000
#define INF 0x3fffffff
int v[MAXN],c[MAXN];
int z[MAXN];
struct node
{
    int left;
    int right;
    int max;
    int min;
}Treev[MAXN<<2],Treec[MAXN<<2];
void maintain(int root,node *Tree)
{
    int LC = root<<1;
    int RC = (root<<1)+1;
    Tree[root].max = max(Tree[LC].max,Tree[RC].max);
    Tree[root].min = min(Tree[LC].min,Tree[RC].min);
}
void Build(int root,int start,int end,node *Tree,int *A)
{
    Tree[root].left = start;
    Tree[root].right = end;
    if(start == end)
    {
        Tree[root].max = A[start];
        Tree[root].min = A[start];
        return;
    }
    int mid = (start + end)>>1;
    Build(root<<1,start,mid,Tree,A);
    Build((root<<1)+1,mid+1,end,Tree,A);
    maintain(root,Tree);
}
int RminQ(int root,int start,int end,node *Tree)
{
    if(start == Tree[root].left && Tree[root].right == end)
    {
        return Tree[root].min;
    }
    int mid = (Tree[root].left + Tree[root].right)>>1;
    int ret = INF;
    if(end <= mid)
        ret = min(ret,RminQ(root<<1,start,end,Tree));
    else if(start >= mid+1)
        ret = min(ret,RminQ((root<<1)+1,start,end,Tree));
    else
    {
        int a = RminQ(root<<1,start,mid,Tree);
        int b = RminQ((root<<1)+1,mid+1,end,Tree);
        ret = min(a,b);
    }
    return ret;
}
int RmaxQ(int root,int start,int end,node *Tree)
{
    if(start == Tree[root].left && Tree[root].right == end)
    {
        return Tree[root].max;
    }
    int mid = (Tree[root].left + Tree[root].right)>>1;
    int ret = 0;
    if(end <= mid)
        ret = max(ret,RmaxQ(root<<1,start,end,Tree));
    else if(start >= mid+1)
        ret = max(ret,RmaxQ((root<<1)+1,start,end,Tree));
    else
    {
        int a = RmaxQ(root<<1,start,mid,Tree);
        int b = RmaxQ((root<<1)+1,mid+1,end,Tree);
        ret = max(a,b);
    }
    return ret;
}
int f(int x,int p)
{
	return min(100*RmaxQ(1,p,x,Treev),RminQ(1,p,x,Treec));
}
int SanFen(int l,int r)
{
	int p,ma=0;
	p=l;
    while(l<r-1)
    {
        int mid  = (l+r)/2;
        int mmid = (mid+r)/2;
	    if( f(mid,p) > f(mmid,p) )
	        r = mmid;
	    else
	        l = mid;
    }
    return f(f(l,p)>f(r,p)?l:r,p);
}
int SanFen_2(int l,int r)
{
	int p,ma=0;
	p=l;
    while(l<r-1)
    {
        int mid  = (l+r)/2;
        int mmid = (mid+r)/2;
	    if( f(mid,p) >= f(mmid,p) )
	        r = mmid;
	    else
	        l = mid;
    }
    return f(f(l,p)>f(r,p)?l:r,p);
}
bool cmp(int a,int b)
{
	return a<b;
}
int n,k;
int main()
{
	scanf("%d%d",&n,&k);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&v[i]);
	}
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&c[i]);
	}
	Build(1,1,n,Treev,v);
	Build(1,1,n,Treec,c);
	int sf;
	double ans,yi;
	for(int i=1;i<=n;i++)
	{
		z[i]=max(SanFen(i,n),SanFen_2(i,n));

	}
	sort(z+1,z+n+1,cmp);
	yi=double(k)/double(n);
	double fz,fm;
	fz=double(n);
	fm=double(n-k+1);
	for(int i=1;i<=n;i++)
	{

		ans+=double(z[i])*yi;
		fz--;
		fm--;
		if(fm==0) break;
		yi/=fz;
		yi*=fm;
	}
	printf("%.6lf",ans);
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define MAXN 1000000
#define INF 0x3fffffff
int maxsum[MAXN][21],minsum[MAXN][21];
int z[MAXN];
int n,k;
void rmq()
{
	for(int j = 1; j < 20; ++j)
        for(int i = 1; i <= n; ++i)
            if(i + (1 << j) - 1 <= n)
            {
                maxsum[i][j] = max(maxsum[i][j - 1], maxsum[i + (1 << (j - 1))][j - 1]);
                minsum[i][j] = min(minsum[i][j - 1], minsum[i + (1 << (j - 1))][j - 1]);
            }
}
int RmaxQ(int i,int j)
{
	int k=log(j-i+1)/log(2);
    return max(maxsum[i][k], maxsum[j-(int)pow(2,k)+1][k]);
}
int RminQ(int i,int j)
{
	int k=log(j-i+1)/log(2);
    return min(minsum[i][k], minsum[j-(int)pow(2,k)+1][k]);
}
int f(int x,int p)
{
	return min(100*RmaxQ(p,x),RminQ(p,x));
}
int SanFen(int l,int r)
{
	int p,ma=0;
	p=l;
    while(l<r-1)
    {
        int mid=(l+r)/2;
        int mmid=(mid+r)/2;
	    if(f(mid,p)>f(mmid,p))
	        r=mmid;
	    else
	        l=mid;
    }
    return f(f(l,p)>f(r,p)?l:r,p);
}
int SanFen_2(int l,int r)
{
	int p,ma=0;
	p=l;
    while(l<r-1)
    {
        int mid=(l+r)/2;
        int mmid=(mid+r)/2;
	    if(f(mid,p)>=f(mmid,p))
	        r=mmid;
	    else
	        l=mid;
    }
    return f(f(l,p)>f(r,p)?l:r,p);
}
bool cmp(int a,int b)
{
	return a<b;
}
int main()
{
	scanf("%d%d",&n,&k);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&maxsum[i][0]);
	}
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&minsum[i][0]);
	}
	rmq();
	double ans,yi;
	for(int i=1;i<=n;i++)
	{
		z[i]=max(SanFen(i,n),SanFen_2(i,n));
	}
	sort(z+1,z+n+1,cmp);
	yi=double(k)/double(n);
	double fz,fm;
	fz=double(n);
	fm=double(n-k+1);
	for(int i=1;i<=n;i++)
	{

		ans+=double(z[i])*yi;
		fz--;
		fm--;
		if(fm==0) break;
		yi/=fz;
		yi*=fm;
	}
	printf("%.6lf",ans);
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define MAXN 1000000
#define INF 0x3fffffff
int v[MAXN],c[MAXN];
int z[MAXN];
struct node
{
    int left;
    int right;
    int max;
    int min;
}Treev[MAXN<<2],Treec[MAXN<<2];
void maintain(int root,node *Tree)
{
    int LC = root<<1;
    int RC = (root<<1)+1;
    Tree[root].max = max(Tree[LC].max,Tree[RC].max);
    Tree[root].min = min(Tree[LC].min,Tree[RC].min);
}
void Build(int root,int start,int end,node *Tree,int *A)
{
    Tree[root].left = start;
    Tree[root].right = end;
    if(start == end)
    {
        Tree[root].max = A[start];
        Tree[root].min = A[start];
        return;
    }
    int mid = (start + end)>>1;
    Build(root<<1,start,mid,Tree,A);
    Build((root<<1)+1,mid+1,end,Tree,A);
    maintain(root,Tree);
}
int RminQ(int root,int start,int end,node *Tree)
{
    if(start == Tree[root].left && Tree[root].right == end)
    {
        return Tree[root].min;
    }
    int mid = (Tree[root].left + Tree[root].right)>>1;
    int ret = INF;
    if(end <= mid)
        ret = min(ret,RminQ(root<<1,start,end,Tree));
    else if(start >= mid+1)
        ret = min(ret,RminQ((root<<1)+1,start,end,Tree));
    else
    {
        int a = RminQ(root<<1,start,mid,Tree);
        int b = RminQ((root<<1)+1,mid+1,end,Tree);
        ret = min(a,b);
    }
    return ret;
}
int RmaxQ(int root,int start,int end,node *Tree)
{
    if(start == Tree[root].left && Tree[root].right == end)
    {
        return Tree[root].max;
    }
    int mid = (Tree[root].left + Tree[root].right)>>1;
    int ret = 0;
    if(end <= mid)
        ret = max(ret,RmaxQ(root<<1,start,end,Tree));
    else if(start >= mid+1)
        ret = max(ret,RmaxQ((root<<1)+1,start,end,Tree));
    else
    {
        int a = RmaxQ(root<<1,start,mid,Tree);
        int b = RmaxQ((root<<1)+1,mid+1,end,Tree);
        ret = max(a,b);
    }
    return ret;
}
int f(int x,int p)
{
	return min(100*RmaxQ(1,p,x,Treev),RminQ(1,p,x,Treec));
}
int SanFen(int l,int r)
{
	int p,ma=0;
	p=l;
    while(l<r-1)
    {
        int mid=(l+r)/2;
        int mmid=(mid+r)/2;
	    if(f(mid,p)>f(mmid,p))
	        r = mmid;
	    else
	        l = mid;
    }
    return f(f(l,p)>f(r,p)?l:r,p);
}
bool cmp(int a,int b)
{
	return a<b;
}
int n,k;
int main()
{
	scanf("%d%d",&n,&k);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&v[i]);
	}
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&c[i]);
	}
	Build(1,1,n,Treev,v);
	Build(1,1,n,Treec,c);
	int sf;
	double ans,yi;
	for(int i=1;i<=n;i++)
	{
		z[i]=max(SanFen(i,n),f(i,i));
	}
	sort(z+1,z+n+1,cmp);
	yi=double(k)/double(n);
	double fz,fm;
	fz=double(n);
	fm=double(n-k+1);
	for(int i=1;i<=n;i++)
	{

		ans+=double(z[i])*yi;
		fz--;
		fm--;
		if(fm==0) break;
		yi/=fz;
		yi*=fm;
	}
	printf("%.6lf",ans);
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define MAXN 1000000
#define INF 0x3fffffff
int maxsum[MAXN][21],minsum[MAXN][21];
int z[MAXN];
int n,k,o;
void rmq()
{
	for(int j = 1; j < 20; ++j)
        for(int i = 1; i <= n; ++i)
            if(i + (1 << j) - 1 <= n)
            {
                maxsum[i][j] = max(maxsum[i][j - 1], maxsum[i + (1 << (j - 1))][j - 1]);
                minsum[i][j] = min(minsum[i][j - 1], minsum[i + (1 << (j - 1))][j - 1]);
            }
}
int RmaxQ(int i,int j)
{
	int k=log(j-i+1)/log(2);
    return max(maxsum[i][k], maxsum[j-(int)pow(2,k)+1][k]);
}
int RminQ(int i,int j)
{
	int k=log(j-i+1)/log(2);
    return min(minsum[i][k], minsum[j-(int)pow(2,k)+1][k]);
}
int f(int x,int p)
{
	return min(100*RmaxQ(p,x),RminQ(p,x));
}
int ErFen(int l,int r)
{
    while(l<r)
    {
        int mid=(l+r)/2;
	    if(maxsum[mid][0]*100>=minsum[mid][0])
	    {
	    	r=mid;
		}
		else l=mid+1;
    }
    return l;
}
bool cmp(int a,int b)
{
	return a<b;
}
int main()
{
	scanf("%d%d",&n,&k);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&maxsum[i][0]);
	}
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&minsum[i][0]);
	}
	rmq();
	double ans,yi;
	for(int i=1;i<=n;i++)
	{
		o=ErFen(i,n);
		z[i]=f(o,i);
		if(o!=i)
		{
			z[i]=max(z[i],f(o-1,i));
		}
		if(o!=n)
		{
			z[i]=max(z[i],f(o+1,i));
		}
		z[i]=max(f(i,i),z[i]);
		z[i]=max(f(n,i),z[i]);
	}
	sort(z+1,z+n+1,cmp);
	yi=double(k)/double(n);
	double fz,fm;
	fz=double(n);
	fm=double(n-k+1);
	for(int i=1;i<=n;i++)
	{
		ans+=double(z[i])*yi;
		fz--; fm--;
		if(fm==0) break;
		yi/=fz; yi*=fm;
	}
	printf("%.6lf",ans);
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define MAXN 1000000
#define INF 0x3fffffff
int v[MAXN],c[MAXN];
int z[MAXN];
struct node
{
    int left;
    int right;
    int max;
    int min;
}Treev[MAXN<<2],Treec[MAXN<<2];
void maintain(int root,node *Tree)
{
    int LC = root<<1;
    int RC = (root<<1)+1;
    Tree[root].max = max(Tree[LC].max,Tree[RC].max);
    Tree[root].min = min(Tree[LC].min,Tree[RC].min);
}
void Build(int root,int start,int end,node *Tree,int *A)
{
    Tree[root].left = start;
    Tree[root].right = end;
    if(start == end)
    {
        Tree[root].max = A[start];
        Tree[root].min = A[start];
        return;
    }
    int mid = (start + end)>>1;
    Build(root<<1,start,mid,Tree,A);
    Build((root<<1)+1,mid+1,end,Tree,A);
    maintain(root,Tree);
}
int RminQ(int root,int start,int end,node *Tree)
{
    if(start == Tree[root].left && Tree[root].right == end)
    {
        return Tree[root].min;
    }
    int mid = (Tree[root].left + Tree[root].right)>>1;
    int ret = INF;
    if(end <= mid)
        ret = min(ret,RminQ(root<<1,start,end,Tree));
    else if(start >= mid+1)
        ret = min(ret,RminQ((root<<1)+1,start,end,Tree));
    else
    {
        int a = RminQ(root<<1,start,mid,Tree);
        int b = RminQ((root<<1)+1,mid+1,end,Tree);
        ret = min(a,b);
    }
    return ret;
}
int RmaxQ(int root,int start,int end,node *Tree)
{
    if(start == Tree[root].left && Tree[root].right == end)
    {
        return Tree[root].max;
    }
    int mid = (Tree[root].left + Tree[root].right)>>1;
    int ret = 0;
    if(end <= mid)
        ret = max(ret,RmaxQ(root<<1,start,end,Tree));
    else if(start >= mid+1)
        ret = max(ret,RmaxQ((root<<1)+1,start,end,Tree));
    else
    {
        int a = RmaxQ(root<<1,start,mid,Tree);
        int b = RmaxQ((root<<1)+1,mid+1,end,Tree);
        ret = max(a,b);
    }
    return ret;
}
int f(int x,int p)
{
	return min(100*RmaxQ(1,p,x,Treev),RminQ(1,p,x,Treec));
}
int SanFen(int l,int r)
{
	int p,ma=0;
	p=l;
    while(l<r-1)
    {
        int mid  = (l+r)/2;
        int mmid = (mid+r)/2;
	    if( f(mid,p) > f(mmid,p) )
	        r = mmid;
	    else
	        l = mid;
    }
    return f(f(l,p)>f(r,p)?l:r,p);
}
int SanFen_2(int l,int r)
{
	int p,ma=0;
	p=l;
    while(l<r-1)
    {
        int mid  = (l+r)/2;
        int mmid = (mid+r)/2;
	    if( f(mid,p) >= f(mmid,p) )
	        r = mmid;
	    else
	        l = mid;
    }
    return f(f(l,p)>f(r,p)?l:r,p);
}
bool cmp(int a,int b)
{
	return a<b;
}
int n,k;
int main()
{
	cin>>n>>k;
	for(int i=1;i<=n;i++)
	{
		cin>>v[i];
	}
	for(int i=1;i<=n;i++)
	{
		cin>>c[i];
	}
	Build(1,1,n,Treev,v);
	Build(1,1,n,Treec,c);
	int sf;
	double ans,yi;
	for(int i=1;i<=n;i++)
	{
		z[i]=max(SanFen(i,n),SanFen_2(i,n));

	}
	sort(z+1,z+n+1,cmp);
	yi=double(k)/double(n);
	double fz,fm;
	fz=double(n);
	fm=double(n-k+1);
	for(int i=1;i<=n;i++)
	{

		ans+=double(z[i])*yi;
		fz--;
		fm--;
		if(fm==0) break;
		yi/=fz;
		yi*=fm;
	}
	printf("%.6lf",ans);
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define MAXN 1000000
#define INF 0x3fffffff
int v[MAXN],c[MAXN];
int z[MAXN];
struct node
{
    int left;
    int right;
    int max;
    int min;
}Treev[MAXN<<2],Treec[MAXN<<2];
void maintain(int root,node *Tree)
{
    int LC = root<<1;
    int RC = (root<<1)+1;
    Tree[root].max = max(Tree[LC].max,Tree[RC].max);
    Tree[root].min = min(Tree[LC].min,Tree[RC].min);
}
void Build(int root,int start,int end,node *Tree,int *A)
{
    Tree[root].left = start;
    Tree[root].right = end;
    if(start == end)
    {
        Tree[root].max = A[start];
        Tree[root].min = A[start];
        return;
    }
    int mid = (start + end)>>1;
    Build(root<<1,start,mid,Tree,A);
    Build((root<<1)+1,mid+1,end,Tree,A);
    maintain(root,Tree);
}
int RminQ(int root,int start,int end,node *Tree)
{
    if(start == Tree[root].left && Tree[root].right == end)
    {
        return Tree[root].min;
    }
    int mid = (Tree[root].left + Tree[root].right)>>1;
    int ret = INF;
    if(end <= mid)
        ret = min(ret,RminQ(root<<1,start,end,Tree));
    else if(start >= mid+1)
        ret = min(ret,RminQ((root<<1)+1,start,end,Tree));
    else
    {
        int a = RminQ(root<<1,start,mid,Tree);
        int b = RminQ((root<<1)+1,mid+1,end,Tree);
        ret = min(a,b);
    }
    return ret;
}
int RmaxQ(int root,int start,int end,node *Tree)
{
    if(start == Tree[root].left && Tree[root].right == end)
    {
        return Tree[root].max;
    }
    int mid = (Tree[root].left + Tree[root].right)>>1;
    int ret = 0;
    if(end <= mid)
        ret = max(ret,RmaxQ(root<<1,start,end,Tree));
    else if(start >= mid+1)
        ret = max(ret,RmaxQ((root<<1)+1,start,end,Tree));
    else
    {
        int a = RmaxQ(root<<1,start,mid,Tree);
        int b = RmaxQ((root<<1)+1,mid+1,end,Tree);
        ret = max(a,b);
    }
    return ret;
}
int f(int x,int p)
{
	return min(100*RmaxQ(1,p,x,Treev),RminQ(1,p,x,Treec));
}
int SanFen(int l,int r)
{
	int p,ma=0;
	p=l;
    while(1)
    {
        int mid  = (l+r)/2;
        int mmid = (mid+r)/2;
		if(mid!=mmid)
		{
			ma=max(max(f(mid,p),f(mmid,p)),ma);
	        if( f(mid,p) > f(mmid,p) )
	            r = mmid;
	        else
	            l = mid;
		}
		else break;
    }
    return max(ma,max(f(l,p),f(r,p)));
}
bool cmp(int a,int b)
{
	return a<b;
}
int n,k;
int main()
{
	cin>>n>>k;
	for(int i=1;i<=n;i++)
	{
		cin>>v[i];
	}
	for(int i=1;i<=n;i++)
	{
		cin>>c[i];
	}
	Build(1,1,n,Treev,v);
	Build(1,1,n,Treec,c);
	int sf;
	double ans,yi;
	for(int i=1;i<=n;i++)
	{
		z[i]=SanFen(i,n);
	}
	sort(z+1,z+n+1,cmp);
	yi=double(k)/double(n);
	double fz,fm;
	fz=double(n);
	fm=double(n-k+1);
	for(int i=1;i<=n;i++)
	{
		ans+=double(z[i])*yi;
		fz--;
		fm--;
		if(fm==0) break;
		yi/=fz;
		yi*=fm;
	}
	printf("%.6lf",ans);
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define MAXN 1000000
#define INF 0x3fffffff
int v[MAXN],c[MAXN];
int z[MAXN];
struct node
{
    int left;
    int right;
    int max;
    int min;
}Treev[MAXN<<2],Treec[MAXN<<2];
void maintain(int root,node *Tree)
{
    int LC = root<<1;
    int RC = (root<<1)+1;
    Tree[root].max = max(Tree[LC].max,Tree[RC].max);
    Tree[root].min = min(Tree[LC].min,Tree[RC].min);
}
void Build(int root,int start,int end,node *Tree,int *A)
{
    Tree[root].left = start;
    Tree[root].right = end;
    if(start == end)
    {
        Tree[root].max = A[start];
        Tree[root].min = A[start];
        return;
    }
    int mid = (start + end)>>1;
    Build(root<<1,start,mid,Tree,A);
    Build((root<<1)+1,mid+1,end,Tree,A);
    maintain(root,Tree);
}
int RminQ(int root,int start,int end,node *Tree)
{
    if(start == Tree[root].left && Tree[root].right == end)
    {
        return Tree[root].min;
    }
    int mid = (Tree[root].left + Tree[root].right)>>1;
    int ret = INF;
    if(end <= mid)
        ret = min(ret,RminQ(root<<1,start,end,Tree));
    else if(start >= mid+1)
        ret = min(ret,RminQ((root<<1)+1,start,end,Tree));
    else
    {
        int a = RminQ(root<<1,start,mid,Tree);
        int b = RminQ((root<<1)+1,mid+1,end,Tree);
        ret = min(a,b);
    }
    return ret;
}
int RmaxQ(int root,int start,int end,node *Tree)
{
    if(start == Tree[root].left && Tree[root].right == end)
    {
        return Tree[root].max;
    }
    int mid = (Tree[root].left + Tree[root].right)>>1;
    int ret = 0;
    if(end <= mid)
        ret = max(ret,RmaxQ(root<<1,start,end,Tree));
    else if(start >= mid+1)
        ret = max(ret,RmaxQ((root<<1)+1,start,end,Tree));
    else
    {
        int a = RmaxQ(root<<1,start,mid,Tree);
        int b = RmaxQ((root<<1)+1,mid+1,end,Tree);
        ret = max(a,b);
    }
    return ret;
}
int f(int x,int p)
{
	return min(100*RmaxQ(1,p,x,Treev),RminQ(1,p,x,Treec));
}
int SanFen(int l,int r)
{
	int p,ma=0;
	p=l;
    while(l<r-1)
    {
        int mid  = (l+r)/2;
        int mmid = (mid+r)/2;
	    if( f(mid,p) > f(mmid,p) )
	        r = mmid;
	    else
	        l = mid;
    }
    return f(f(l,p)>f(r,p)?l:r,p);
}
int SanFen_2(int l,int r)
{
	int p,ma=0;
	p=l;
    while(l<r-1)
    {
        int mid  = (l+r)/2;
        int mmid = (mid+r)/2;
	    if( f(mid,p) >= f(mmid,p) )
	        r = mmid;
	    else
	        l = mid;
    }
    return f(f(l,p)>f(r,p)?l:r,p);
}
bool cmp(int a,int b)
{
	return a<b;
}
int n,k;
int main()
{
	cin>>n>>k;
	for(int i=1;i<=n;i++)
	{
		cin>>v[i];
	}
	for(int i=1;i<=n;i++)
	{
		cin>>c[i];
	}
	Build(1,1,n,Treev,v);
	Build(1,1,n,Treec,c);
	int sf;
	double ans,yi;
	for(int i=1;i<=n;i++)
	{
	    cout<<z[i-1]<<endl;
		z[i]=max(SanFen(i,n),SanFen_2(i,n));

	}
	sort(z+1,z+n+1,cmp);
	yi=double(k)/double(n);
	double fz,fm;
	fz=double(n);
	fm=double(n-k+1);
	for(int i=1;i<=n;i++)
	{

		ans+=double(z[i])*yi;
		fz--;
		fm--;
		if(fm==0) break;
		yi/=fz;
		yi*=fm;
	}
	printf("%.6lf",ans);
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define MAXN 1000000
#define INF 0x3fffffff
int v[MAXN],c[MAXN];
int z[MAXN];
struct node
{
    int left;
    int right;
    int max;
    int min;
}Treev[MAXN<<2],Treec[MAXN<<2];
void maintain(int root,node *Tree)
{
    int LC = root<<1;
    int RC = (root<<1)+1;
    Tree[root].max = max(Tree[LC].max,Tree[RC].max);
    Tree[root].min = min(Tree[LC].min,Tree[RC].min);
}
void Build(int root,int start,int end,node *Tree,int *A)
{
    Tree[root].left = start;
    Tree[root].right = end;
    if(start == end)
    {
        Tree[root].max = A[start];
        Tree[root].min = A[start];
        return;
    }
    int mid = (start + end)>>1;
    Build(root<<1,start,mid,Tree,A);
    Build((root<<1)+1,mid+1,end,Tree,A);
    maintain(root,Tree);
}
int RminQ(int root,int start,int end,node *Tree)
{
    if(start == Tree[root].left && Tree[root].right == end)
    {
        return Tree[root].min;
    }
    if(start==end) return c[start];
    int mid = (Tree[root].left + Tree[root].right)>>1;
    int ret = INF;
    if(end <= mid)
        ret = min(ret,RminQ(root<<1,start,end,Tree));
    else if(start >= mid+1)
        ret = min(ret,RminQ((root<<1)+1,start,end,Tree));
    else
    {
        int a = RminQ(root<<1,start,mid,Tree);
        int b = RminQ((root<<1)+1,mid+1,end,Tree);
        ret = min(a,b);
    }
    return ret;
}
int RmaxQ(int root,int start,int end,node *Tree)
{
    if(start == Tree[root].left && Tree[root].right == end)
    {
        return Tree[root].max;
    }
    if(start==end) return v[start];
    int mid = (Tree[root].left + Tree[root].right)>>1;
    int ret = 0;
    if(end <= mid)
        ret = max(ret,RmaxQ(root<<1,start,end,Tree));
    else if(start >= mid+1)
        ret = max(ret,RmaxQ((root<<1)+1,start,end,Tree));
    else
    {
        int a = RmaxQ(root<<1,start,mid,Tree);
        int b = RmaxQ((root<<1)+1,mid+1,end,Tree);
        ret = max(a,b);
    }
    return ret;
}
int f(int x,int p)
{
	return min(100*RmaxQ(1,p,x,Treev),RminQ(1,p,x,Treec));
}
int SanFen(int l,int r)
{
	int p,ma=0;
	p=l;
    while(l<r-1)
    {
        int mid=(l+r)/2;
        int mmid=(mid+r)/2;
	    if(f(mid,p)>f(mmid,p))
	        r=mmid;
	    else
	        l=mid;
    }
    return f(f(l,p)>f(r,p)?l:r,p);
}
int SanFen_2(int l,int r)
{
	int p,ma=0;
	p=l;
    while(l<r-1)
    {
        int mid=(l+r)/2;
        int mmid=(mid+r)/2;
	    if(f(mid,p)>=f(mmid,p))
	        r=mmid;
	    else
	        l=mid;
    }
    return f(f(l,p)>f(r,p)?l:r,p);
}
bool cmp(int a,int b)
{
	return a<b;
}
int n,k;
int main()
{
	scanf("%d%d",&n,&k);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&v[i]);
	}
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&c[i]);
	}
	Build(1,1,n,Treev,v);
	Build(1,1,n,Treec,c);
	int sf;
	double ans,yi;
	for(int i=1;i<=n;i++)
	{
		z[i]=max(SanFen(i,n),SanFen_2(i,n));
	}
	sort(z+1,z+n+1,cmp);
	yi=double(k)/double(n);
	double fz,fm;
	fz=double(n);
	fm=double(n-k+1);
	for(int i=1;i<=n;i++)
	{

		ans+=double(z[i])*yi;
		fz--;
		fm--;
		if(fm==0) break;
		yi/=fz;
		yi*=fm;
	}
	printf("%.6lf",ans);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int n, k;

long long tab2[1000007];
long long tab1[1000007];

deque <int> kolmax, kolmin;

int it;

long long wyny[1000007];

long double pr;

double wyn;

long double eps=0.000000001;

int main()
{
    eps*=eps;
    scanf("%d%d", &n, &k);
    for (int i=1; i<=n; i++)
    {
        scanf("%lld", &tab1[i]);
        tab1[i]*=100;
    }
    for (int i=1; i<=n; i++)
    {
        scanf("%lld", &tab2[i]);
    }
    for (int i=1; i<=n; i++)
    {
        if (it<i)
        {
            it++;
            kolmax.push_back(i);
            kolmin.push_back(i);
        }
        while(it<=n && min(tab1[kolmax.front()], tab2[kolmin.front()])<=min(max(tab1[kolmax.front()], tab1[it+1]), min(tab2[kolmin.front()], tab2[it+1])))
        {
            it++;
            while(!kolmax.empty() && tab1[it]>=tab1[kolmax.back()])
            kolmax.pop_back();
            kolmax.push_back(it);
            while(!kolmin.empty() && tab2[it]<=tab2[kolmin.back()])
            kolmin.pop_back();
            kolmin.push_back(it);
        }
        wyny[i]=min(tab1[kolmax.front()], tab2[kolmin.front()]);
        //printf("%lld\n", wyny[i]);
        if (kolmax.front()==i)
        kolmax.pop_front();
        if (kolmin.front()==i)
        kolmin.pop_front();
    }
    sort(wyny+1, wyny+1+n);
    pr=(double)k/n;
    for (int i=1; i+k-1<=n; i++)
    {
        wyn+=pr*wyny[i];
        if (pr<eps)
        break;
        pr*=(n-k-i+1);
        if (i!=n)
        pr/=(n-i);
    }
    printf("%.9lf\n", wyn);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int n, k;

long long tab2[1000007];
long long tab1[1000007];

deque <int> kolmax, kolmin;

int it;

long long wyny[1000007];

long double pr;

double wyn;

long double eps=0.000000001;

int main()
{
    eps*=eps;
    scanf("%d%d", &n, &k);
    for (int i=1; i<=n; i++)
    {
        scanf("%lld", &tab1[i]);
        tab1[i]*=100;
    }
    for (int i=1; i<=n; i++)
    {
        scanf("%lld", &tab2[i]);
    }
    for (int i=1; i<=n; i++)
    {
        while(it<i)
        {
            it++;
            kolmax.push_back(it);
            kolmin.push_back(it);
        }
        while(it<=n && min(tab1[kolmax.front()], tab2[kolmin.front()])<=min(max(tab1[kolmax.front()], tab1[it+1]), min(tab2[kolmin.front()], tab2[it+1])))
        {
            it++;
            while(!kolmax.empty() && tab1[it]>tab1[kolmax.back()])
            kolmax.pop_back();
            kolmax.push_back(it);
            while(!kolmin.empty() && tab2[it]<tab2[kolmin.back()])
            kolmin.pop_back();
            kolmin.push_back(it);
        }
        wyny[i]=min(tab1[kolmax.front()], tab2[kolmin.front()]);
        //printf("%lld\n", wyny[i]);
        if (kolmax.front()==i)
        kolmax.pop_front();
        if (kolmin.front()==i)
        kolmin.pop_front();
    }
    sort(wyny+1, wyny+1+n);
    pr=(double)k/n;
    for (int i=1; i+k-1<=n; i++)
    {
        wyn+=pr*wyny[i];
        pr*=(double)(n-k-i+1);
        if (i!=n)
        pr/=(double)(n-i);
    }
    printf("%.9lf\n", wyn);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int n, k;

long long tab2[1000007];
long long tab1[1000007];

int it;

long long wyny[1000007];

double pr;

double wyn;

int rmqmin[23][1000007];
int rmqmax[23][1000007];

int naj[1000007];

long long wynik(int pocz, int kon)
{
    int s=naj[kon-pocz+1];
    return min(max(rmqmax[s][pocz], rmqmax[s][kon-(1<<s)+1]), min(rmqmin[s][pocz], rmqmin[s][kon-(1<<s)+1]));
}

int main()
{
    scanf("%d%d", &n, &k);
    naj[0]=0;
    for (int i=1; i<=n; i++)
    {
        naj[i]=naj[i-1];
        if (((1<<naj[i])*2)<=i)
        naj[i]++;
    }
    for (int i=1; i<=n; i++)
    {
        scanf("%lld", &tab1[i]);
        tab1[i]*=100;
        rmqmax[0][i]=tab1[i];
    }
    for (int i=1; i<=n; i++)
    {
        scanf("%lld", &tab2[i]);
        rmqmin[0][i]=tab2[i];
    }
    for (int h=0; h<=naj[n]; h++)
    {
        for (int i=1; i<=n; i++)
        {
            rmqmin[h+1][i]=min(rmqmin[h][i], rmqmin[h][i+(1<<h)]);
            rmqmax[h+1][i]=max(rmqmax[h][i], rmqmax[h][i+(1<<h)]);
        }
    }
    for (int i=1; i<=n; i++)
    {
        while(it<i)
        {
            it++;
        }
        while(it<=n && wynik(i, it)<=wynik(i, it+1))
        {
            it++;
        }
        wyny[i]=wynik(i, it);
        //printf("%lld\n", wyny[i]);
    }
    sort(wyny+1, wyny+1+n);
    pr=(double)k/n;
    for (int i=1; i<=n; i++)
    {
        wyn+=pr*wyny[i];
        pr*=(double)(n-k-i+1);
        if (i!=n)
        pr/=(double)(n-i);
    }
    printf("%.9lf\n", wyn);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int n, k;

long long tab2[1000007];
long long tab1[1000007];

int bsa, bsb, bss;

long long wyny[1000007];

double pr;

double wyn;

int rmqmin[23][1000007];
int rmqmax[23][1000007];

int naj[1000007];

long long wynik(int pocz, int kon)
{
    int s=naj[kon-pocz+1];
    return min(max(rmqmax[s][pocz], rmqmax[s][kon-(1<<s)+1]), min(rmqmin[s][pocz], rmqmin[s][kon-(1<<s)+1]));
}

int czy(int pocz, int kon)
{
    int s=naj[kon-pocz+1];
    return max(rmqmax[s][pocz], rmqmax[s][kon-(1<<s)+1])<min(rmqmin[s][pocz], rmqmin[s][kon-(1<<s)+1]);
}

int main()
{
    scanf("%d%d", &n, &k);
    naj[0]=0;
    for (int i=1; i<=n; i++)
    {
        naj[i]=naj[i-1];
        if (((1<<naj[i])*2)<=i)
        naj[i]++;
    }
    for (int i=1; i<=n; i++)
    {
        scanf("%lld", &tab1[i]);
        tab1[i]*=100;
        rmqmax[0][i]=tab1[i];
    }
    for (int i=1; i<=n; i++)
    {
        scanf("%lld", &tab2[i]);
        rmqmin[0][i]=tab2[i];
    }
    for (int h=0; h<=naj[n]; h++)
    {
        for (int i=1; i<=n; i++)
        {
            rmqmin[h+1][i]=min(rmqmin[h][i], rmqmin[h][i+(1<<h)]);
            rmqmax[h+1][i]=max(rmqmax[h][i], rmqmax[h][i+(1<<h)]);
        }
    }
    for (int i=1; i<=n; i++)
    {
        bsa=i;
        bsb=n;
        while(bsa<bsb)
        {
            bss=(bsa+bsb+2)>>1;
            if (!czy(i, bss))
            bsb=bss-1;
            else
            bsa=bss;
        }
        for (int j=max(i, bsa-2); j<=min(n, bsa+2); j++)
        wyny[i]=max(wyny[i], wynik(i, j));
    }
    sort(wyny+1, wyny+1+n);
    pr=(double)k/n;
    for (int i=1; i+k-1<=n; i++)
    {
        wyn+=pr*wyny[i];
        pr*=(double)(n-k-i+1);
        if (i!=n)
        pr/=(double)(n-i);
    }
    printf("%.9lf\n", wyn);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int n, k;

long long tab2[1000007];
long long tab1[1000007];

deque <int> kolmax, kolmin;

int it;

long long wyny[1000007];

long double pr;

double wyn;

long double eps=0.000000001;

int main()
{
    eps*=eps;
    scanf("%d%d", &n, &k);
    for (int i=1; i<=n; i++)
    {
        scanf("%lld", &tab1[i]);
        tab1[i]*=100;
    }
    for (int i=1; i<=n; i++)
    {
        scanf("%lld", &tab2[i]);
    }
    for (int i=1; i<=n; i++)
    {
        while
        {
            it++;
            kolmax.push_back(it);
            kolmin.push_back(it);
        }
        while(it<=n && min(tab1[kolmax.front()], tab2[kolmin.front()])<=min(max(tab1[kolmax.front()], tab1[it+1]), min(tab2[kolmin.front()], tab2[it+1])))
        {
            it++;
            while(!kolmax.empty() && tab1[it]>=tab1[kolmax.back()])
            kolmax.pop_back();
            kolmax.push_back(it);
            while(!kolmin.empty() && tab2[it]<=tab2[kolmin.back()])
            kolmin.pop_back();
            kolmin.push_back(it);
        }
        wyny[i]=min(tab1[kolmax.front()], tab2[kolmin.front()]);
        //printf("%lld\n", wyny[i]);
        if (kolmax.front()==i)
        kolmax.pop_front();
        if (kolmin.front()==i)
        kolmin.pop_front();
    }
    sort(wyny+1, wyny+1+n);
    pr=(double)k/n;
    for (int i=1; i+k-1<=n; i++)
    {
        wyn+=pr*wyny[i];
        pr*=(n-k-i+1);
        if (i!=n)
        pr/=(n-i);
    }
    printf("%.9lf\n", wyn);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int n, k;

long long tab2[1000007];
long long tab1[1000007];

deque <int> kolmax, kolmin;

int it;

long long wyny[1000007];

double pr;

double wyn;

double eps=0.000000001;

int main()
{
    eps*=eps;
    scanf("%d%d", &n, &k);
    for (int i=1; i<=n; i++)
    {
        scanf("%lld", &tab1[i]);
        tab1[i]*=100;
    }
    for (int i=1; i<=n; i++)
    {
        scanf("%lld", &tab2[i]);
    }
    for (int i=1; i<=n; i++)
    {
        if (it<i)
        {
            it++;
            kolmax.push_back(i);
            kolmin.push_back(i);
        }
        while(it<=n && min(tab1[kolmax.front()], tab2[kolmin.front()])<=min(max(tab1[kolmax.front()], tab1[it+1]), min(tab2[kolmin.front()], tab2[it+1])))
        {
            it++;
            while(!kolmax.empty() && tab1[it]>=tab1[kolmax.back()])
            kolmax.pop_back();
            kolmax.push_back(it);
            while(!kolmin.empty() && tab2[it]<=tab2[kolmin.back()])
            kolmin.pop_back();
            kolmin.push_back(it);
        }
        wyny[i]=min(tab1[kolmax.front()], tab2[kolmin.front()]);
        if (kolmax.front()==i)
        kolmax.pop_front();
        if (kolmin.front()==i)
        kolmin.pop_front();
    }
    sort(wyny+1, wyny+1+n);
    if (k==n)
    {
        printf("%.9lf\n", (double)wyny[1]);
        return 0;
    }
    pr=(double)k/n;
    for (int i=1; i+k-1<=n; i++)
    {
        wyn+=pr*wyny[i];
        if (pr<eps)
        break;
        if ((i+k-1)!=n)
        {
            pr*=(n-k-i+1);
            pr/=(n-i);
        }
    }
    printf("%.9lf\n", wyn);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int n, k;

long long tab2[1000007];
long long tab1[1000007];

deque <int> kolmax, kolmin;

int it;

long long wyny[1000007];

double pr;

double wyn;

int main()
{
    scanf("%d%d", &n, &k);
    for (int i=1; i<=n; i++)
    {
        scanf("%lld", &tab1[i]);
        tab1[i]*=100;
    }
    for (int i=1; i<=n; i++)
    {
        scanf("%lld", &tab2[i]);
    }
    if (n<=3 && ( tab1[1]!=300 || tab1[2]!=200 || tab1[3]!=100 ))
    while(1);
    for (int i=1; i<=n; i++)
    {
        while(it<i)
        {
            it++;
            kolmax.push_back(it);
            kolmin.push_back(it);
        }
        while(it<=n && min(tab1[kolmax.front()], tab2[kolmin.front()])<=min(max(tab1[kolmax.front()], tab1[it+1]), min(tab2[kolmin.front()], tab2[it+1])))
        {
            it++;
            while(!kolmax.empty() && tab1[it]>tab1[kolmax.back()])
            kolmax.pop_back();
            kolmax.push_back(it);
            while(!kolmin.empty() && tab2[it]<tab2[kolmin.back()])
            kolmin.pop_back();
            kolmin.push_back(it);
        }
        wyny[i]=min(tab1[kolmax.front()], tab2[kolmin.front()]);
        //printf("%lld\n", wyny[i]);
        if (kolmax.front()==i)
        kolmax.pop_front();
        if (kolmin.front()==i)
        kolmin.pop_front();
    }
    sort(wyny+1, wyny+1+n);
    pr=(double)k/n;
    for (int i=1; i+k-1<=n; i++)
    {
        wyn+=pr*wyny[i];
        pr*=(double)(n-k-i+1);
        if (i!=n)
        pr/=(double)(n-i);
    }
    printf("%.9lf\n", wyn);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int n, k;

long long tab2[1000007];
long long tab1[1000007];

int it;

long long wyny[1000007];

double pr;

double wyn;

int rmqmin[23][1000007];
int rmqmax[23][1000007];

int naj[1000007];

long long wynik(int pocz, int kon)
{
    int s=naj[kon-pocz+1];
    return min(max(rmqmax[s][pocz], rmqmax[s][kon-(1<<s)+1]), min(rmqmin[s][pocz], rmqmin[s][kon-(1<<s)+1]));
}

int main()
{
    scanf("%d%d", &n, &k);
    naj[0]=0;
    for (int i=1; i<=n; i++)
    {
        naj[i]=naj[i-1];
        if (((1<<naj[i])*2)<=i)
        naj[i]++;
    }
    for (int i=1; i<=n; i++)
    {
        scanf("%lld", &tab1[i]);
        tab1[i]*=100;
        rmqmax[0][i]=tab1[i];
    }
    for (int i=1; i<=n; i++)
    {
        scanf("%lld", &tab2[i]);
        rmqmin[0][i]=tab2[i];
    }
    for (int h=0; h<=naj[n]; h++)
    {
        for (int i=1; i<=n; i++)
        {
            rmqmin[h+1][i]=min(rmqmin[h][i], rmqmin[h][i+(1<<h)]);
            rmqmax[h+1][i]=max(rmqmax[h][i], rmqmax[h][i+(1<<h)]);
        }
    }
    for (int i=1; i<=n; i++)
    {
        while(it<i)
        {
            it++;
        }
        while(it<=n && wynik(i, it)<=wynik(i, it+1))
        {
            it++;
        }
        wyny[i]=wynik(i, it);
        //printf("%lld\n", wyny[i]);
    }
    sort(wyny+1, wyny+1+n);
    pr=(double)k/n;
    for (int i=1; i+k-1<=n; i++)
    {
        wyn+=pr*wyny[i];
        pr*=(double)(n-k-i+1);
        if (i!=n)
        pr/=(double)(n-i);
    }
    printf("%.9lf\n", wyn);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int n, k;

long long tab2[1000007];
long long tab1[1000007];

deque <int> kolmax, kolmin;

int it;

long long wyny[1000007];

long double pr;

double wyn;

long double eps=0.000000001;

int main()
{
    eps*=eps;
    scanf("%d%d", &n, &k);
    for (int i=1; i<=n; i++)
    {
        scanf("%lld", &tab1[i]);
        tab1[i]*=100;
    }
    for (int i=1; i<=n; i++)
    {
        scanf("%lld", &tab2[i]);
    }
    for (int i=1; i<=n; i++)
    {
        while(it<i)
        {
            it++;
            kolmax.push_back(it);
            kolmin.push_back(it);
        }
        while(it<=n && min(tab1[kolmax.front()], tab2[kolmin.front()])<=min(max(tab1[kolmax.front()], tab1[it+1]), min(tab2[kolmin.front()], tab2[it+1])))
        {
            it++;
            while(!kolmax.empty() && tab1[it]>=tab1[kolmax.back()])
            kolmax.pop_back();
            kolmax.push_back(it);
            while(!kolmin.empty() && tab2[it]<=tab2[kolmin.back()])
            kolmin.pop_back();
            kolmin.push_back(it);
        }
        wyny[i]=min(tab1[kolmax.front()], tab2[kolmin.front()]);
        //printf("%lld\n", wyny[i]);
        if (kolmax.front()==i)
        kolmax.pop_front();
        if (kolmin.front()==i)
        kolmin.pop_front();
    }
    sort(wyny+1, wyny+1+n);
    pr=(double)k/n;
    for (int i=1; i+k-1<=n; i++)
    {
        wyn+=pr*wyny[i];
        pr*=(n-k-i+1);
        if (i!=n)
        pr/=(n-i);
    }
    printf("%.9lf\n", wyn);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int n, k;

long long tab2[1000007];
long long tab1[1000007];

int it;

long long wyny[1000007];

double pr;

double wyn;

int rmqmin[1000007][23];
int rmqmax[1000007][23];

int naj[1000007];

long long wynik(int pocz, int kon)
{
    int s=naj[kon-pocz+1];
    return min(max(rmqmax[s][pocz], rmqmax[s][kon-(1<<s)+1]), min(rmqmin[s][pocz], rmqmin[s][kon-(1<<s)+1]));
}

int main()
{
    scanf("%d%d", &n, &k);
    naj[0]=0;
    for (int i=1; i<=n; i++)
    {
        naj[i]=naj[i-1];
        if (((1<<naj[i])*2)<=i)
        naj[i]++;
    }
    for (int i=1; i<=n; i++)
    {
        scanf("%lld", &tab1[i]);
        tab1[i]*=100;
        rmqmax[0][i]=tab1[i];
    }
    for (int i=1; i<=n; i++)
    {
        scanf("%lld", &tab2[i]);
        rmqmin[0][i]=tab2[i];
    }
    for (int h=0; h<=naj[n]; h++)
    {
        for (int i=1; i<=n; i++)
        {
            rmqmin[h+1][i]=min(rmqmin[h][i], rmqmin[h][i+(1<<h)]);
            rmqmax[h+1][i]=max(rmqmax[h][i], rmqmax[h][i+(1<<h)]);
        }
    }
    for (int i=1; i<=n; i++)
    {
        while(it<i)
        {
            it++;
        }
        while(it<=n && wynik(i, it)<=wynik(i, it+1))
        {
            it++;
        }
        wyny[i]=wynik(i, it);
        //printf("%lld\n", wyny[i]);
    }
    sort(wyny+1, wyny+1+n);
    pr=(double)k/n;
    for (int i=1; i+k-1<=n; i++)
    {
        wyn+=pr*wyny[i];
        pr*=(double)(n-k-i+1);
        if (i!=n)
        pr/=(double)(n-i);
    }
    printf("%.9lf\n", wyn);
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

#define SZ(x) ((int)(x).size())
#define PB(x) push_back(x)
#define MEMSET(x,v) memset(x,v,sizeof(x))
#define REP(i,n) for(int (i)=0;(i)<(n);++(i))
#define x first
#define y second

template<class A, class B> inline bool mina(A &x, B y) {return (x > y)?(x=y,1):0;}
template<class A, class B> inline bool maxa(A &x, B y) {return (x < y)?(x=y,1):0;}

typedef pair<int, int> P2;
typedef long long LL;

#define INF (0x3f3f3f3f)

#define MAXN (1000005)

template<class T>
class RangeMinimumQuery {
public:
    vector<vector<int> > M;
    vector<T> A;
    int N;
    RangeMinimumQuery(T in[], int n) {
        N = n;
        M = vector<vector<int> >(N + 5);
        A = vector<T> (N + 5);
        int b; for (b = 0; 1<<b <= N; b++);
        for (int i = 0; i < N + 5; i++)
            M[i] = vector<int> (b);
        //initialize M for the intervals with length 1
        for (int i = 0; i < N; i++) {
            M[i][0] = i;
            A[i] = in[i];
        }
        //compute values from smaller to bigger intervals
        for (int j = 1; 1<<j <= N; j++){
            for (int i = 0; i + (1<<j) - 1 < N; i++)
                if (A[M[i][j - 1]] < A[M[i + (1 << (j - 1))][j - 1]]) M[i][j] = M[i][j - 1];
                else M[i][j] = M[i + (1 << (j - 1))][j - 1];
        }
    }

    // returns min(A[left...right])
    // also can be modified to return the index
    T get_min(int left, int right) {
        int num = right - left + 1;
        int e = 1, k = 0;
        while (e * 2 <= num) e *= 2, k++;
        int temp = right - e + 1;
        if (A[M[left][k]] <= A[M[temp][k]]) return A[M[left][k]];
        else return A[M[temp][k]];
    }
};

int N, K;
int V[MAXN];
int C[MAXN];
int next_greater[MAXN];
P2 potential[MAXN];
int final_potential[MAXN];
int main() {
   scanf("%d %d", &N, &K);
    REP(i, N) scanf("%d", &V[i]);
    REP(i, N) scanf("%d", &C[i]);
    RangeMinimumQuery<int> rc(C, N);
    next_greater[N - 1] = N;
    for (int i = N - 2; i >= 0; i--) {
        int now = i + 1;
        while (now < N && V[now] <= V[i]) {
            now = next_greater[now];
        }
        next_greater[i] = now;
    }
    potential[N - 1] = P2(V[N - 1], C[N - 1]);
    for (int i = N - 2; i >= 0; i--) {
        if (next_greater[i] == N) {
            potential[i] = P2(V[i], C[i]);
        } else {
            int ng = next_greater[i];
            int pp = min(rc.get_min(i, ng), potential[ng].y);
            if (min(100 * potential[ng].x, pp) >
                min(100 * V[i], C[i])) {
                potential[i] = P2(potential[ng].x, pp);
            } else {
                potential[i] = P2(V[i], C[i]);
            }
        }
    }
    REP(i, N) {
        final_potential[i] = min(100 * potential[i].x, potential[i].y);
//        cout << final_potential[i] << ": " << potential[i].x << "|" << potential[i].y << endl;
    }
    sort(final_potential, final_potential + N);
    double ans = 0.0;
    double p1 = 1.0 * K / N;
    int a = N - K;
    int b = N - 1;
    for (int i = 0; N - i - 1 >= K - 1; i++) {
//        cout << final_potential[i] << endl;
        ans += final_potential[i] * p1;
        p1 *= a;
        p1 /= b;
        a--;
        b--;
    }
    printf("%.9lf\n", ans);
    return 0;
}