Arraangia

#include <bits/stdc++.h>

using namespace std;

long long MOD = 998244353;

long long power(long long base, long long exp) {
    long long res = 1;
    base %= MOD;
    while (exp > 0) {
        if (exp % 2 == 1) res = (res * base) % MOD;
        base = (base * base) % MOD;
        exp /= 2;
    }
    return res;
}

long long modInverse(long long n) {
    return power(n, MOD - 2);
}

vector<long long> fact;
vector<long long> invFact;

void precompute_factorials(int n) {
    fact.resize(n + 1);
    invFact.resize(n + 1);
    fact[0] = 1;
    invFact[0] = 1;
    for (int i = 1; i <= n; i++) {
        fact[i] = (fact[i - 1] * i) % MOD;
        invFact[i] = modInverse(fact[i]);
    }
}

long long nCr_mod_p(int n, int r) {
    if (r < 0 || r > n) {
        return 0;
    }
    return (((fact[n] * invFact[r]) % MOD) * invFact[n - r]) % MOD;
}

long long clac(int N, int K, vector<int>& A) {
    sort(A.begin(), A.end());

    map<int, int> counts;
    for (int x : A) {
        counts[x]++;
    }

    vector<int> c_values;
    for(auto const& [val, num] : counts){
        c_values.push_back(num);
    }

    precompute_factorials(N + 5);

    vector<long long> dp(N + 1, 0);
    dp[0] = 1;
    int current_size = c_values[0];

    for (size_t i = 1; i < c_values.size(); ++i) {
        vector<long long> next_dp(N + 1, 0);
        int c = c_values[i];
        int n_prev = current_size;

        for (int j = 0; j <= n_prev + c && j <= K; ++j) {
            long long total_ways = 0;
            for (int k = 0; k <= j && k < n_prev; ++k) {
                if (dp[k] == 0) continue;

                int l = j - k;
                if (l < 0 || l > c) continue;

                long long term1 = nCr_mod_p(n_prev - k, l);
                long long term2 = nCr_mod_p(c + k, j);

                long long ways = (term1 * term2) % MOD;
                total_ways = (total_ways + (dp[k] * ways) % MOD) % MOD;
            }
            next_dp[j] = total_ways;
        }

        dp = next_dp;
        current_size += c;
    }

    if (K >= current_size) return 0;
    return dp[K];
}

int main() {
    int N, K;
    cin >> N >> K;

    vector<int> A(N);
    for (int i = 0; i < N; ++i) {
        cin >> A[i];
    }

    long long result = clac(N, K, A);
    cout << result << endl;

    return 0;
}