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

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define fi first
#define se second
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const int INF = (1<<30) - 1;
const ll LINF = (1LL<<62) - 1;

template <typename Monoid>
struct SegTree {
    using F = function<Monoid(Monoid, Monoid)>;
    const F f;
    const Monoid unit;

    int n;
    vector<Monoid> dat;

    SegTree(int n_, const F f_, const Monoid unit_) : f(f_), unit(unit_) {
        n = 1;
        while (n < n_) n *= 2;
        // 1-indexed
        dat.assign(2 * n, unit);
    }

    void set(int i, const Monoid &x) {
        dat[i + n] = x;
    }
    void build() {
        for (int i = n - 1; i >= 0; --i) {
            dat[i] = f(dat[2 * i], dat[2 * i + 1]);
        }
    }

    void update(int i, const Monoid &x){
        i += n;
        dat[i] = x;
        while (i >>= 1){
            dat[i] = f(dat[2 * i], dat[2 * i + 1]);
        }
    }

    // [a, b) 非再帰
    Monoid query(int a, int b) {
        Monoid l = unit, r = unit;
        for (a += n, b += n; a < b; a >>= 1, b >>= 1) {
            if (a & 1) l = f(l, dat[a++]);
            if (b & 1) r = f(dat[--b], r);
        }
        return f(l, r);
    }

    inline Monoid operator[] (int i){
        return dat[i + n];
    }
};
// set(i, v)した後にbuild()でO(n)
// 区間和 : SegTree<int> seg(n, [](int a, int b){ return a + b; }, 0);
// 区間min : SegTree<int> seg(n, [](int a, int b) {return min(a, b); }, INF);


int main(){
    int n, m, k;
    cin >> n >> m >> k;
    vector<int> a(k);
    int modoru[100010] = {};
    for (int i = 0; i < k; ++i) {
        cin >> a[i];
        modoru[a[i]] = 1;
    }

    int cnt = 0;
    for (int i = 0; i <= n; ++i) {
        if (modoru[i]) cnt++;
        else cnt = 0;
        if (cnt >= m) {
            cout << -1 << endl;
            return 0;
        }
    }

    SegTree<double> seg(n + m + 10, [](double a, double b){ return a + b; }, 0);
    SegTree<double> seg2(n + m + 10, [](double a, double b){ return a + b; }, 0);
    for (int i = n-1; i >= 0; --i) {
        double a = seg.query(i + 1, i + m + 1) / m + 1.0;
        double b = seg2.query(i + 1, i + m + 1) / m;

        if (modoru[i]) {
            seg2.update(i, 1.0);
        } else {
            seg.update(i, a);
            seg2.update(i, b);
        }
    }

    // x = seg[0] + seg2[0] * x
    cout << fixed << setprecision(15) << seg[0] / (1 - seg2[0]) << endl;
}
#include<bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
using namespace std;
// typedef tree<pair<int,int>, null_type, less<pair<int,int>>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;
#define ll long long 
#define scn(n) scanf("%d",&n)
#define lscn(n) scanf("%lld",&n)
#define lpri(n) printf("%lld",n)
#define pri(n) printf("%d",n)
#define pln() printf("\n")
#define priln(n) printf("%d\n",n)
#define lpriln(n) printf("%lld\n",n)
#define rep(i,init,n) for(int i=init;i<n;i++)
#define pb push_back     
#define mp make_pair
#define F first
#define S second
#define gcd __gcd
#define inf INT_MAX
#define ninf INT_MIN   
#define inf INT_MAX
#define linf LLONG_MAX
#define lninf LLONG_MIN   
const int mod = 1e9 + 7;
const int N = 1e5 + 4;
typedef long double ld;

int solve()
{
	int n, m, k; scn(n); scn(m); scn(k);

	pair<ld, ld> p = {0.0, 0.0};

	vector<int> mark(n + 1, 0);

	rep(i, 0, k)
	{
		int val; scn(val);

		mark[val]++;
	}

	int cnt = 0;

	rep(i, 1, n)
	{
		if(mark[i])
		cnt++;
		else
		{
			if(cnt >= m)
			{
				pri(-1); return 0;
			}

			cnt = 0;
		}
	}	

	if(cnt >= m)
	{
		pri(-1); return 0;
	}
	
	vector<pair<ld, ld>> v(n + m + 1, {0.0, 0.0});

	for(int i = n - 1; i >= 0; i--)
	{
		p.F -= v[i + m + 1].F; p.S -= v[i + m + 1].S;

		if(mark[i])
		{
			v[i].F = 1.0; 
		}
		else
		{
			v[i].F = p.F / (ld)m; v[i].S = p.S / (ld)m;

			v[i].S += 1.0;
		}

		// cout << v[i].F << " " << v[i].S << endl;

		if(i == 0)
		cout << fixed << setprecision(10) << v[i].S / (1.0 - v[i].F);

		p.F += v[i].F; p.S += v[i].S; 
	}

	return 0;
}

int main()                  
{
	int t = 1; //scn(t);

	while(t--)
	{
		solve();
	}

    return 0;
}