#include <bits/stdc++.h>
using namespace std;
using Int = long long;
const char newl = '\n';
template <typename T1, typename T2>
inline void chmin(T1& a, T2 b) {
  if (a > b) a = b;
}
template <typename T1, typename T2>
inline void chmax(T1& a, T2 b) {
  if (a < b) a = b;
}
template <typename T>
void drop(const T& x) {
  cout << x << endl;
  exit(0);
}
template <typename T = int>
vector<T> read(size_t n) {
  vector<T> ts(n);
  for (size_t i = 0; i < n; i++) cin >> ts[i];
  return ts;
}
template <typename T, T MOD = 1000000007>
struct Mint {
  static constexpr T mod = MOD;
  T v;
  Mint() : v(0) {}
  Mint(signed v) : v(v) {}
  Mint(long long t) {
    v = t % MOD;
    if (v < 0) v += MOD;
  }
  Mint pow(long long k) {
    Mint res(1), tmp(v);
    while (k) {
      if (k & 1) res *= tmp;
      tmp *= tmp;
      k >>= 1;
    }
    return res;
  }
  static Mint add_identity() { return Mint(0); }
  static Mint mul_identity() { return Mint(1); }
  Mint inv() { return pow(MOD - 2); }
  Mint& operator+=(Mint a) {
    v += a.v;
    if (v >= MOD) v -= MOD;
    return *this;
  }
  Mint& operator-=(Mint a) {
    v += MOD - a.v;
    if (v >= MOD) v -= MOD;
    return *this;
  }
  Mint& operator*=(Mint a) {
    v = 1LL * v * a.v % MOD;
    return *this;
  }
  Mint& operator/=(Mint a) { return (*this) *= a.inv(); }
  Mint operator+(Mint a) const { return Mint(v) += a; }
  Mint operator-(Mint a) const { return Mint(v) -= a; }
  Mint operator*(Mint a) const { return Mint(v) *= a; }
  Mint operator/(Mint a) const { return Mint(v) /= a; }
  Mint operator-() const { return v ? Mint(MOD - v) : Mint(v); }
  bool operator==(const Mint a) const { return v == a.v; }
  bool operator!=(const Mint a) const { return v != a.v; }
  bool operator<(const Mint a) const { return v < a.v; }
  static Mint comb(long long n, int k) {
    Mint num(1), dom(1);
    for (int i = 0; i < k; i++) {
      num *= Mint(n - i);
      dom *= Mint(i + 1);
    }
    return num / dom;
  }
};
template <typename T, T MOD>
constexpr T Mint<T, MOD>::mod;
template <typename T, T MOD>
ostream& operator<<(ostream& os, Mint<T, MOD> m) {
  os << m.v;
  return os;
}
template <typename T>
class BIT {
 private:
  T sum(int i) {
    T s(0);
    for (int x = i; x > 0; x -= (x & -x)) s += bit[x];
    return s;
  }

 public:
  int n;
  vector<T> bit;
  BIT(int n_) : n(n_ + 1), bit(n + 1, 0) {}
  void add(int i, T a) {
    for (int x = ++i; x <= n; x += (x & -x)) bit[x] += a;
  }
  T query(int l, int r) { return sum(r) - sum(l); }
  int lower_bound(const T w) {
    if (w <= 0) return 0;
    T r = w;
    int x = 0, p = 1;
    while (p < n) p <<= 1;
    for (int k = p; k > 0; k >>= 1) {
      if (x + k <= n && bit[x + k] < r) {
        r -= bit[x + k];
        x += k;
      }
    }
    x++;
    assert(sum(x - 1) < w and sum(x) >= w);
    return x;
  }
  int upper_bound(T w) { return lower_bound(w + 1); }
};
template <typename M_>
class Enumeration {
  using M = M_;

 protected:
  static vector<M> fact, finv, invs;

 public:
  static void init(int n) {
    n = min<decltype(M::mod)>(n, M::mod - 1);
    int m = fact.size();
    if (n < m) return;
    fact.resize(n + 1, 1);
    finv.resize(n + 1, 1);
    invs.resize(n + 1, 1);
    if (m == 0) m = 1;
    for (int i = m; i <= n; i++) fact[i] = fact[i - 1] * M(i);
    finv[n] = M(1) / fact[n];
    for (int i = n; i >= m; i--) finv[i - 1] = finv[i] * M(i);
    for (int i = m; i <= n; i++) invs[i] = finv[i] * fact[i - 1];
  }
  static M Fact(int n) {
    init(n);
    return fact[n];
  }
  static M Finv(int n) {
    init(n);
    return finv[n];
  }
  static M Invs(int n) {
    init(n);
    return invs[n];
  }
  static M C(int n, int k) {
    if (n < k || k < 0) return M(0);
    init(n);
    return fact[n] * finv[n - k] * finv[k];
  }
  static M P(int n, int k) {
    if (n < k || k < 0) return M(0);
    init(n);
    return fact[n] * finv[n - k];
  }
  static M H(int n, int k) {
    if (n < 0 || k < 0) return M(0);
    if (!n && !k) return M(1);
    init(n + k);
    return C(n + k - 1, n);
  }
};
template <typename M>
vector<M> Enumeration<M>::fact = vector<M>();
template <typename M>
vector<M> Enumeration<M>::finv = vector<M>();
template <typename M>
vector<M> Enumeration<M>::invs = vector<M>();
signed main() {
  cin.tie(0);
  ios::sync_with_stdio(0);
  int n, k;
  cin >> n >> k;
  auto ps = read(n);
  for (int& p : ps) p--;
  using M = Mint<int, 998244353>;
  using E = Enumeration<M>;
  E::init(3e5);
  M ans{0};
  ans += M(k * (k - 1) / 2) / M(2);
  BIT<M> bit(n), cnt(n);
  for (int i = 0; i < k; i++) {
    int p = ps[i];
    bit.add(p, M(1));
    cnt.add(p, M(1));
  }
  M ofs{1};
  M ratio = M(k - 1) / M(k);
  for (int i = k; i < n; i++) {
    ofs *= ratio;
    int p = ps[i];
    ans += (bit.query(0, n)) * ofs / M(2);
    ans += (cnt.query(p, n) - bit.query(p, n) * ofs);
    bit.add(p, M(1) / ofs);
    cnt.add(p, M(1));
  }
  cout << ans << newl;
  return 0;
}
