// clang-format off
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

#define mp make_pair
#define fst first
#define snd second
#define forn(i,n) for (int i = 0; i < int(n); i++)
#define forn1(i,n) for (int i = 1; i <= int(n); i++)
#define popcnt __builtin_popcountll
#define ffs __builtin_ffsll
#define ctz __builtin_ctzll
#define clz __builtin_clz
#define clzll __builtin_clzll
#define all(a) (a).begin(), (a).end()

using namespace std;
using namespace __gnu_pbds;

using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int,int>;
using pli = pair<ll,int>;
using pil = pair<int,ll>;
using pll = pair<ll,ll>;
template <typename T> using vec = vector<T>;
using vi = vec<int>;
using vl = vec<ll>;
template <typename T> using que = queue<T>;
template <typename T> using deq = deque<T>;

template <typename T> T id(T b) {return b;};
template <typename T> void chmax(T &x, T y) {if (x < y) x = y;}
template <typename T> void chmin(T &x, T y) {if (x > y) x = y;}
template <typename S, typename K> bool contains(S &s, K k) { return s.find(k) != s.end(); }
void fastio() { ios_base::sync_with_stdio(false); cin.tie(nullptr); }
constexpr ll TEN(int n) { if (n == 0) return 1LL; else return 10LL*TEN(n-1); }
template <typename T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <typename K, typename V> using ordered_map = tree<K, V, less<K>, rb_tree_tag, tree_order_statistics_node_update>;
// clang-format on

int main() {
    fastio();

    int n, m, k;
    cin >> n >> m >> k;
    vec<bool> r(n + 1, false);
    forn(i, k) {
        int x;
        cin >> x;
        r[x] = true;
    }

    vec<pair<double, double>> dp(n + m);

    pair<double, double> s = { 0.0, 0.0 };
    for (int i = n - 1; i >= 0; i--) {
        if (r[i])
            dp[i] = mp(1.0, 0.0);
        else {
            dp[i].fst += s.fst / m;
            dp[i].snd += s.snd / m;
            dp[i].snd += 1;
        }

        if (i + m <= n) {
            s.fst -= dp[i + m].fst;
            s.snd -= dp[i + m].snd;
        }
        s.fst += dp[i].fst;
        s.snd += dp[i].snd;
    }

    auto [a, b] = dp[0];

    if (abs(a - 1.0) <= 1e-6) {
        cout << "-1\n";
    } else {
        cout << fixed << setprecision(10) << b / (1.0 - a) << endl;
    }

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

int n, m, k;
vector<long long> a, nxt;

long double solve();
bool check(long double e);

int main() {
  cin >> n >> m >> k;
  a.resize(k);
  for (auto &p : a) cin >> p;
  cout << fixed << setprecision(10);
  auto res = solve();
  if (res < 0)
    cout << "-1" << endl;
  else
    cout << solve() << endl;
  return 0;
}

long double solve() {
  nxt.resize(n + m + 1);
  for (int i = 0; i < n + m + 1; ++i) {
    nxt[i] = i + m;
    for (int j = 0; j < k; ++j)
      if (i <= a[j]) nxt[i] = min(nxt[i], a[j]);
  }
  for (int i = 0; i < k;) {
    int now = a[i], cnt = 0;
    while (i < k && now == a[i]) ++i, ++now, ++cnt;
    if (cnt >= m) return -1;
  }
  long double l = 0, r = 1e18;
  for (int t = 0; t < 200; ++t) {
    long double mid = (l + r) / 2;
    if (check(mid))
      r = mid;
    else
      l = mid;
  }
  return r;
}

bool check(long double e) {
  vector<long double> dp(n + m, 0);
  long double now = 0;
  for (int i = n - 1; i >= 0; --i) {
    if (nxt[i] == i)
      dp[i] = e;
    else
      dp[i] = 1 + now / m;
    now += dp[i];
    now -= dp[i + m];
  }
  return dp[0] <= e;
}