#include <bits/stdc++.h>
using namespace std;
int totInv(int l, int r) { return ((r + 1 - l) * (r - l)) / 2; }
inline int totp(int n) { return n + (n * (n - 1)) / 2; }
long double dp[200][35][35];
int main() {
  int N, K;
  int A[30];
  cin >> N >> K;
  for (int i = 0; i < N; i++) cin >> A[i];
  for (int k = 0; k <= K; k++)
    for (int i = 0; i < (N + 5); i++)
      for (int j = 0; j < (N + 5); j++) dp[k][i][j] = 0.0;
  for (int i = 0; i < N; i++) {
    dp[0][i][i] = 0;
    for (int j = (i + 1); j < N; j++) {
      dp[0][i][j] = dp[0][i][j - 1];
      for (int k = i; k < j; k++)
        if (A[k] > A[j]) dp[0][i][j]++;
    }
  }
  int totPairs = totp(N);
  for (int k = 1; k <= K; k++) {
    for (int i = 0; i < N; i++) {
      dp[k][i][i] = 0;
      for (int j = i; j < N; j++) {
        dp[k][i][j] = 0;
        for (int l = 0; l < i; l++) {
          for (int r = i; r <= j; r++) {
            dp[k][i][j] +=
                (dp[k - 1][l][j] - dp[k - 1][l][r] -
                 dp[k - 1][l + r - i + 1][j] + dp[k - 1][l + r - i + 1][r] +
                 (totInv(l, l + r - i) - dp[k - 1][l][l + r - i]) +
                 dp[k - 1][r + 1][j]) /
                totPairs;
          }
          for (int r = (N - 1); r > j; r--) {
            dp[k][i][j] +=
                (totInv(i, j) - dp[k - 1][l + r - j][l + r - i]) / totPairs;
          }
        }
        for (int r = (N - 1); r > j; r--) {
          for (int l = j; l >= i; l--) {
            dp[k][i][j] += (dp[k - 1][l][l + r - j - 1] - dp[k - 1][l][r] -
                            dp[k - 1][i][l + r - j - 1] + dp[k - 1][i][r] +
                            dp[k - 1][i][l - 1] +
                            (totInv(l + r - j, r) - dp[k - 1][l + r - j][r])) /
                           totPairs;
          }
        }
        for (int l = i; l <= j; l++) {
          for (int r = l; r <= j; r++) {
            dp[k][i][j] += ((dp[k - 1][i][j] - dp[k - 1][l][r]) +
                            (totInv(l, r) - dp[k - 1][l][r])) /
                           totPairs;
          }
        }
        dp[k][i][j] +=
            ((totp(i) + totp(N - 1 - j)) * (dp[k - 1][i][j])) / totPairs;
      }
    }
  }
  cout << setprecision(20) << dp[K][0][N - 1] << endl;
  return 0;
}
