#include <bits/stdc++.h>
const int MAXN = 100 + 10;
int n, k;
int p[MAXN];
namespace solver1 {
long long ans = 0, cur = 0;
void dfs(int x) {
  if (x > k) {
    cur++;
    for (int i = 1; i <= n; i++) {
      for (int j = 1; j < i; j++) {
        ans += p[j] > p[i];
      }
    }
    return;
  }
  for (int i = 1; i <= n; i++) {
    for (int j = i; j <= n; j++) {
      std::reverse(p + i, p + j + 1);
      dfs(x + 1);
      std::reverse(p + i, p + j + 1);
    }
  }
}
void main() {
  dfs(1);
  printf("%.12f\n", 1.0 * ans / cur);
}
}  // namespace solver1
namespace solver2 {
double f[2][MAXN][MAXN];
void main() {
  double p0 = 1.0 / (n * (n + 1) / 2);
  int cur = 1;
  for (int i = 1; i <= n; i++) {
    for (int j = 1; j < i; j++) {
      f[cur][i][j] = p[j] > p[i];
    }
  }
  for (int ttt = 1; ttt <= k; ttt++) {
    memset(f[cur ^ 1], 0, sizeof f[cur ^ 1]);
    for (int l = 1; l <= n; l++) {
      for (int r = l; r <= n; r++) {
        for (int i = 1; i <= n; i++) {
          for (int j = 1; j < i; j++) {
            int np = (l <= i && i <= r) ? (l + r - i) : i;
            int nq = (l <= j && j <= r) ? (l + r - j) : j;
            if (np < nq) std::swap(np, nq);
            f[cur ^ 1][np][nq] +=
                p0 * ((l <= i && i <= r && l <= j && j <= r) ? 1 - f[cur][i][j]
                                                             : f[cur][i][j]);
          }
        }
      }
    }
    cur ^= 1;
  }
  double ans = 0;
  for (int i = 1; i <= n; i++) {
    for (int j = 1; j < i; j++) {
      ans += f[cur][i][j];
    }
  }
  for (int i = 1; i <= n; i++) {
    for (int j = i + 1; j <= n; j++) {
      fprintf(stderr, "%.12f ", f[cur][j][i]);
    }
    fprintf(stderr, "\n");
  }
  printf("%.12f\n", ans);
}
}  // namespace solver2
namespace solver_std {
double f[2][MAXN][MAXN];
void main() {
  k = std::min(k, 1000);
  int cur = 1;
  for (int i = 1; i <= n; i++) {
    for (int j = i + 1; j <= n; j++) {
      f[cur][i][j] = p[i] > p[j];
    }
  }
  double p0 = 1.0 / (n * (n + 1) / 2);
  for (int ttt = 1; ttt <= k; ttt++) {
    memset(f[cur ^ 1], 0, sizeof f[cur ^ 1]);
    for (int i = 1; i <= n; i++) {
      for (int j = i + 1; j <= n; j++) {
        int t = (j - i - 1) * (j - i) / 2 + (i - 1) * i / 2 +
                (n - j) * (n - j + 1) / 2;
        f[cur ^ 1][i][j] += f[cur][i][j] * t * p0;
      }
    }
    static double s0[MAXN], s1[MAXN];
    for (int j = 1; j <= n; j++) {
      for (int i = 1; i < j; i++) {
        s0[i] = s0[i - 1] + f[cur][i][j];
        s1[i] = s1[i - 1] + f[cur][i][j] * i;
      }
      for (int i = 1; i < j; i++) {
        f[cur ^ 1][i][j] += p0 * s1[std::min(j - i, i)];
        if (j - i <= i) {
          f[cur ^ 1][i][j] += p0 * (j - i) * (s0[i] - s0[j - i]);
        } else {
          f[cur ^ 1][i][j] += p0 * i * (s0[j - i] - s0[i]);
        }
        f[cur ^ 1][i][j] += p0 * (j * (s0[j - 1] - s0[std::max(j - i, i)]) -
                                  (s1[j - 1] - s1[std::max(j - i, i)]));
      }
    }
    for (int i = 1; i <= n; i++) {
      for (int j = n; j > i; j--) {
        s0[j] = s0[j + 1] + f[cur][i][j];
        s1[j] = s1[j + 1] + f[cur][i][j] * j;
      }
      for (int j = n; j > i; j--) {
        f[cur ^ 1][i][j] += p0 * ((n + 1) * s0[std::max(j, n + 1 + i - j)] -
                                  s1[std::max(j, n + 1 + i - j)]);
        if (j <= n + 1 + i - j) {
          f[cur ^ 1][i][j] += p0 * (j - i) * (s0[j] - s0[n + 1 + i - j]);
        } else {
          f[cur ^ 1][i][j] += p0 * (n - j + 1) * (s0[n + 1 + i - j] - s0[j]);
        }
        f[cur ^ 1][i][j] +=
            p0 * (s1[i + 1] - s1[std::min(j, n + 1 + i - j)] -
                  i * (s0[i + 1] - s0[std::min(j, n + 1 + i - j)]));
      }
    }
    for (int delta = 1; delta < n; delta++) {
      for (int i = 1; i + delta <= n; i++) {
        s0[i] = s0[i - 1] + (1 - f[cur][i][i + delta]);
        s1[i] = s1[i - 1] + (1 - f[cur][i][i + delta]) * i;
      }
      for (int i = 1; i + delta <= n; i++) {
        int j = i + delta;
        f[cur ^ 1][i][j] += p0 * s1[std::min(n - j + 1, i)];
        if (n - j + 1 <= i) {
          f[cur ^ 1][i][j] += p0 * (n - j + 1) * (s0[i] - s0[n - j + 1]);
        } else {
          f[cur ^ 1][i][j] += p0 * i * (s0[n - j + 1] - s0[i]);
        }
        f[cur ^ 1][i][j] +=
            p0 *
            ((i + n - j + 1) * (s0[n - delta] - s0[std::max(n - j + 1, i)]) -
             (s1[n - delta] - s1[std::max(n - j + 1, i)]));
      }
    }
    cur ^= 1;
  }
  double ans = 0;
  for (int i = 1; i <= n; i++) {
    for (int j = i + 1; j <= n; j++) {
      ans += f[cur][i][j];
    }
  }
  printf("%.12f\n", ans);
}
}  // namespace solver_std
int main() {
  scanf("%d%d", &n, &k);
  for (int i = 1; i <= n; i++) {
    scanf("%d", p + i);
  }
  solver_std::main();
}
