#include <bits/stdc++.h>
#define err(args...) {}
#ifdef DEBUG
#include "_debug.cpp"
#endif
using namespace std;
using ll = long long;
using ld = long double;
template <typename T> using lim = numeric_limits<T>;
template <typename T> istream& operator>>(istream& is, vector<T>& a) { for(T& x : a) { is >> x; } return is; }
template <typename X, typename Y> istream& operator>>(istream& is, pair<X, Y>& p) { return is >> p.first >> p.second; }
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int n, m, k;
    cin >> n >> m >> k;
    vector<int> a(k), max_consec(k);
    cin >> a;
    if(k > 0) {
        max_consec[0] = 1;
    }
    for(int i = 1; i < k; i++) {
        max_consec[i] = (a[i] == a[i - 1] + 1 ? max_consec[i - 1] : 0) + 1;
    }
    if(k > 0 and *max_element(max_consec.begin(), max_consec.end()) >= m) {
        cout << -1 << endl;
    } else {
        vector<pair<double, double>> E(n + m + 1);
        pair<double, double> psum = {0, 0};
        for(int i = n - 1; i >= 0; i--) {
            psum.first -= E[i + m + 1].first / m;
            psum.second -= E[i + m + 1].second / m;
            if(find(a.begin(), a.end(), i) != a.end()) {
                E[i] = {1.0, 0};
            } else {
                E[i] = {psum.first, psum.second + 1};
            }
            psum.first += E[i].first / m;
            psum.second += E[i].second / m;
        }
        cout << fixed << setprecision(3) << E[0].second / (1 - E[0].first) << endl;
    }
    return 0;
}

#include<bits/stdc++.h>

int main(){
    using namespace std;
    unsigned long N, M, K;
    cin >> N >> M >> K;
    const auto unavailable{[&N, &M, &K]{
        vector<unsigned long> unavailable(N + 1);
        vector<unsigned long> ban;
        for(unsigned long i{0}, a; i < K; ++i){
            cin >> a;
            unavailable[a] = 1;
            ban.push_back(a);
        }
        sort(begin(ban), end(ban));
        for(unsigned long i{M - 1}; i < K; ++i)if(ban[i - M + 1] + M - 1 == ban[i])exit(puts("-1") & 0);
        return unavailable;
    }()};
    const auto iteration{[&N, &M, &unavailable](long double x) -> long double {
        vector<long double> dp(N + 1);
        long double now{0}, c{0}, tmp{0}, y{0};
        for(unsigned long i{N}; i--; ){
            dp[i] = unavailable[i] ? x : now / M + 1;
            now += dp[i];
            now -= dp[min(N, i + M)];
        }
        return dp[0];
    }};
    constexpr long double eps{1e-10};
    cout << setprecision(15) << [&iteration]{
        auto tmp{[&iteration]{
            auto [l, r]{[&iteration]{
                if(2 > iteration(2))return make_pair(1.0L, 2.0L);
                long double r{2};
                while(r * r < iteration(r * r))r *= r;
                return make_pair(r, r * r);
            }()};
            for(unsigned long i{0}; i < 100; ++i){
                long double m{sqrt(l) * sqrt(r)};
                (m < iteration(m) ? l : r) = m;
            }
            return l;
        }()};
        for(unsigned long i{0}; i < 100; ++i)tmp = iteration(tmp);
        return tmp;
    }() << endl;
    return 0;
}
