#include <bits/stdc++.h>
#define all(x) (x).begin(),(x).end()
using namespace std;

using ll = long long;
using ld = long double;

//#define int ll
#define sz(x) ((int)(x).size())

using pii = pair<int,int>;
using tii = tuple<int,int,int>;

const int mod = 998244353;
struct Mint {
  int val;
  Mint(ll x = 0): val((x % mod + mod) % mod) {;}
  Mint operator +(const Mint& x) { return Mint(val + x.val); }
  Mint operator -(const Mint& x) { return Mint(val - x.val); }
  Mint operator *(const Mint& x) { return Mint((ll)val * x.val); }
  Mint operator +=(const Mint& x) { return *this = Mint(val + x.val); }
  Mint operator -=(const Mint& x) { return *this = Mint(val - x.val); }
  Mint operator *=(const Mint& x) { return *this = Mint((ll)val * x.val); }
  Mint operator ^(const int& _b) const {
    Mint accum = 1, a = *this;
    int b = _b;
    while(b) {
      accum = (b & 1? accum * a : accum);
      a *= a;
      b >>= 1;
    }
    return accum;
  }
  Mint operator /(const Mint& x) { return Mint((ll)val * (x ^ (mod - 2)).val); }
  Mint operator /=(const Mint& x) { return *this = Mint((ll)val * (x ^ (mod - 2)).val); }
};

const int nmax = 1e3 + 5;

int disconcerting[nmax][nmax];
Mint dp[nmax][nmax];
bool vizited[nmax][nmax];

Mint fact[nmax];
Mint imperfect[nmax];

int n;
vector<int> v;

Mint recurr(int suff, int k) { // e enervanta asimetria asta
   if(suff == n + 1) {
      if(k == 0) return 1;
      return 0;
   }
   if(vizited[suff][k]) return dp[suff][k];
   
   if(n - suff + 1 == k) return 1;
   
   vizited[suff][k] = 1;
   
   //if(suff == 4 && k == 2) cerr << disconcerting[suff][v[suff]] << '\n';
   
   if(disconcerting[suff][v[suff]]) { // il aduceai mai devreme daca puteai, deci era in sufixul prost; ai largit sufixul, a intrat in prefix bun (de unde ""poti"" sa muti elemente); daca nu il muti, ramane ceva din ochelari "mai mare" decat maximul anterior. Deci mai bine il muti
                                      // e si unic!! (?)
      dp[suff][k] = fact[n - suff + 1 - k];
      
      for(int i = suff + 1; i <= n - k + 1; i++)
          dp[suff][k] *= Mint(1 - disconcerting[suff][v[i]]);
      for(int i = suff + 1; i <= n - k + 1; i++)
         if(v[i] < v[i - 1]) return dp[suff][k] = 0;
      return dp[suff][k];
   }
   
   if(k == 1) {
      for(int i = suff + 1; i <= n; i++) {
         if(v[i] < v[i - 1]) return dp[suff][k] = 0;
      }
      return dp[suff][k] = fact[n - suff + 1];
   }
   
   if(!(*max_element(v.begin(), v.begin() + suff) == suff - 1)) return dp[suff][k] = 0;
   int lst = -1;
   for(int i = suff; i <= n - k + 1; i++) {
      if(v[i] < lst) break;
      lst = v[i];
      dp[suff][k] += recurr(i + 1, k - 1) * imperfect[i - suff + 1];
   }
   return dp[suff][k];
}

signed main() {
   cin.tie(0) -> sync_with_stdio(0);
   int k;
   cin >> n;
   cin >> k;
   
   v = vector<int>(n + 1, 0);
   for(auto &x : v | views::drop(1)) cin >> x;
   
   fact[0] = 1;
   for(int i = 1; i <= n; i++) {
      fact[i] = fact[i - 1] * i;
      imperfect[i] = fact[i];
      for(int dim = 1; dim < i; dim++)
         imperfect[i] -= imperfect[dim] * fact[i - dim];
      
      //cerr << imperfect[i].val << ' ';
      
      int mx = *max_element(v.begin(), v.begin() + i);
      for(int j = i; j <= n; j++)
         disconcerting[i][v[j]] = v[j] <= mx;
   }
   
   //imperfect[1] = 0;
   
   cout << recurr(1, k).val << '\n';
   
   
   
}

/**
  Anul asta nu se da centroid
  -- Rugaciunile mele
*/