#include<bits/stdc++.h>

using namespace std;
typedef long long ll;

#define rep(i,n) for (long long i = 0; i < (n); ++i)
#define DIV 1000000007 //10^9+7
#define INF LONG_MAX/3
#define bit(n) (1LL<<(n))

template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};

int main(){
	ll N, M, K;
	cin >> N >> M >> K;
	vector<bool> loop(N, false);
	rep(i, K) {
		ll a;
		cin >> a;
		loop[a] = true;
	}
	vector<pair<double, double> >dp(N + M - 1);
	rep(i, N + M - 1) dp[i].first = 0;
	rep(i, N + M - 1) dp[i].second = 0;

	double a = 0;
	double b = 0;
	for(ll i = N - 1; i >= 0; i--) {
		a += dp[i + 1].first;
		b += dp[i + 1].second;
		a -= dp[i + 1 + M].first;
		b -= dp[i + 1 + M].second;

		if(loop[i]) {
			dp[i].first = 1;
			dp[i].second = 0;
		} else {
			dp[i].first = a/(double)M;
			dp[i].second = b/(double)M + 1;
		}
		//cout << "dp[" << i << "] = " << dp[i].first << " x + " << dp[i].second << endl;
	}

	if(dp[0].first > 1 - 0.000001 && dp[0].first <  1 + 0.000001) {
		cout << -1 << endl;
	} else {
		printf("%.10f\n", dp[0].second/(1-dp[0].first));
	}
}

#include <functional>
#include <iostream>
#include <iomanip>
#include <vector>
using namespace std;

const double eps = 1e-9;

template <typename T>
struct SegmentTree
{
    using F = function<T(T, T)>;
    
    const F f;
    const T e;
    
    int n;
    vector<T> seg;
    
    SegmentTree(int nn, const F f, const T e) : f(f), e(e){
        n = 1;
        while(n < nn) n <<= 1;
        seg.assign(n * 2, e);
    }
    
    void set(int i, T x){
        seg[i + n] = x;
    }
    
    void build(){
        for(int k = n - 1; k > 0; k--){
            seg[k] = f(seg[k * 2], seg[k * 2 + 1]);
        }
    }
    
    void update(int i, T x){
        int k = i + n;
        seg[k] = x;
        while(k >>= 1){
            seg[k] = f(seg[k * 2], seg[k * 2 + 1]);
        }
    }
    
    T query(int l, int r){
        l += n, r += n;
        T L = e, R = e;
        for(; l != r; l >>= 1, r >>= 1){
            if(l % 2) L = f(L, seg[l++]);
            if(r % 2) R = f(seg[--r], R);
        }
        return f(L, R);
    }
    
    T operator[](const int i)const {
        return seg[i + n];
    }
    
    template<typename C>
    int right_bound_sub(int k, const C &check, T x){
        while(k < n){
            if(check(f(x, seg[k * 2]))){
                k = k * 2;
            }
            else{
                x = f(x, seg[k * 2]);
                k = k * 2 + 1;
            }
        }
        return k - n;
    }
    
    template <typename C>
    int right_bound(int i, const C &check){
        T x = e;
        for(int l = i + n, r = n * 2; l != r; l >>= 1, r >>= 1){
            if(l % 2){
                if(check(f(x, seg[l]))){
                    return right_bound_sub(l, check, x);
                }
                x = f(x, seg[l]);
                l++;
            }
        }
        return -1;
    }
    
    template <typename C>
    int left_bound_sub(int k, const C &check, T x){
        while(k < n){
            if(check(f(seg[k * 2 + 1], x))){
                k = k * 2 + 1;
            }
            else{
                x = f(seg[k * 2 + 1], x);
                k = k * 2;
            }
        }
        return k - n;
    }
    
    template <typename C>
    int left_bound(int i, const C &check){
        T x = e;
        for(int l = n, r = i + n; l != r; l >>= 1, r >>= 1){
            if(r % 2){
                if(check(f(seg[--r], x))){
                    return left_bound_sub(r, check, x);
                }
                x = f(x, seg[r]);
            }
        }
        return -1;
    }
};

int main()
{
    int n, m, k;
    cin >> n >> m >> k;
    SegmentTree<double> seg0(n + m, [](double a, double b){return a + b;}, 0);
    SegmentTree<double> sego(n + m, [](double a, double b){return a + b;}, 0);
    for(int i = 0; i < k; i++){
        int a;
        cin >> a;
        seg0.update(a, 1);
    }
    seg0.build();
    for(int i = n - 1; i >= 0; i--){
        if(seg0[i] > 0.5) continue;
        seg0.update(i, seg0.query(i, i + m + 1) / m);
        sego.update(i, sego.query(i, i + m + 1) / m + 1);
    }
    if(seg0[0] > 1 - eps) cout << -1 << endl;
    else cout << fixed << setprecision(15) << sego[0] / (1 - seg0[0]) << endl;
}
