#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
struct mod_int {
  int val;
  mod_int(long long v = 0) {
    if (v < 0) v = v % MOD + MOD;
    if (v >= MOD) v %= MOD;
    val = v;
  }
  static int mod_inv(int a, int m = MOD) {
    int g = m, r = a, x = 0, y = 1;
    while (r != 0) {
      int q = g / r;
      g %= r;
      swap(g, r);
      x -= q * y;
      swap(x, y);
    }
    return x < 0 ? x + m : x;
  }
  explicit operator int() const { return val; }
  mod_int &operator+=(const mod_int &other) {
    val += other.val;
    if (val >= MOD) val -= MOD;
    return *this;
  }
  mod_int &operator-=(const mod_int &other) {
    val -= other.val;
    if (val < 0) val += MOD;
    return *this;
  }
  static unsigned fast_mod(uint64_t x, unsigned m = MOD) {
    return x % m;
    unsigned x_high = x >> 32, x_low = (unsigned)x;
    unsigned quot, rem;
    asm("divl %4\n" : "=a"(quot), "=d"(rem) : "d"(x_high), "a"(x_low), "r"(m));
    return rem;
  }
  mod_int &operator*=(const mod_int &other) {
    val = fast_mod((uint64_t)val * other.val);
    return *this;
  }
  mod_int &operator/=(const mod_int &other) { return *this *= other.inv(); }
  friend mod_int operator+(const mod_int &a, const mod_int &b) {
    return mod_int(a) += b;
  }
  friend mod_int operator-(const mod_int &a, const mod_int &b) {
    return mod_int(a) -= b;
  }
  friend mod_int operator*(const mod_int &a, const mod_int &b) {
    return mod_int(a) *= b;
  }
  friend mod_int operator/(const mod_int &a, const mod_int &b) {
    return mod_int(a) /= b;
  }
  mod_int &operator++() {
    val = val == MOD - 1 ? 0 : val + 1;
    return *this;
  }
  mod_int &operator--() {
    val = val == 0 ? MOD - 1 : val - 1;
    return *this;
  }
  mod_int operator++(int) {
    mod_int before = *this;
    ++*this;
    return before;
  }
  mod_int operator--(int) {
    mod_int before = *this;
    --*this;
    return before;
  }
  mod_int operator-() const { return val == 0 ? 0 : MOD - val; }
  bool operator==(const mod_int &other) const { return val == other.val; }
  bool operator!=(const mod_int &other) const { return val != other.val; }
  mod_int inv() const { return mod_inv(val); }
  mod_int pow(long long p) const {
    assert(p >= 0);
    mod_int a = *this, result = 1;
    while (p > 0) {
      if (p & 1) result *= a;
      a *= a;
      p >>= 1;
    }
    return result;
  }
  friend ostream &operator<<(ostream &stream, const mod_int &m) {
    return stream << m.val;
  }
};
vector<mod_int> inv = {0, 1}, factorial = {1, 1}, inv_factorial = {1, 1};
int prepared_size = 2;
void prepare_factorials(int maximum) {
  static int prepare_calls = 0;
  if (prepare_calls++ == 0) {
    for (int p = 2; p * p <= MOD; p++) assert(MOD % p != 0);
  }
  if (maximum >= prepared_size) {
    inv.resize(maximum + 1);
    factorial.resize(maximum + 1);
    inv_factorial.resize(maximum + 1);
    for (int i = prepared_size; i <= maximum; i++) {
      inv[i] = inv[MOD % i] * (MOD - MOD / i);
      factorial[i] = i * factorial[i - 1];
      inv_factorial[i] = inv[i] * inv_factorial[i - 1];
    }
    prepared_size = maximum + 1;
  }
}
mod_int choose(long long n, long long r) {
  if (r < 0 || r > n) return 0;
  if (n >= prepared_size) prepare_factorials(n);
  return factorial[n] * inv_factorial[r] * inv_factorial[n - r];
}
mod_int inv_choose(long long n, long long r) {
  assert(0 <= r && r <= n);
  if (n >= prepared_size) prepare_factorials(n);
  return inv_factorial[n] * factorial[r] * factorial[n - r];
}
mod_int permute(long long n, long long k) {
  if (k < 0 || k > n) return 0;
  if (n >= prepared_size) prepare_factorials(n);
  return factorial[n] * inv_factorial[n - k];
}
mod_int inv_permute(long long n, long long k) {
  assert(0 <= k && k <= n);
  if (n >= prepared_size) prepare_factorials(n);
  return inv_factorial[n] * factorial[n - k];
}
int N, K;
vector<int> H;
int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  cin >> N >> K;
  H.resize(N);
  for (int &h : H) cin >> h;
  if (K == 1) {
    cout << 0 << '\n';
    return 0;
  }
  H.push_back(H[0]);
  int different = 0;
  for (int i = 0; i < N; i++) different += H[i] != H[i + 1];
  mod_int total = 0;
  mod_int INV2 = mod_int(2).inv();
  for (int zeros = 0; zeros < different; zeros++) {
    int remaining = different - zeros;
    mod_int ways = 0;
    if (remaining % 2 == 1) {
      ways = mod_int(2).pow(remaining - 1);
    } else {
      ways = mod_int(2).pow(remaining - 1) -
             choose(remaining, remaining / 2) * INV2;
    }
    ways *= choose(different, zeros);
    ways *= mod_int(K - 2).pow(zeros);
    total += ways;
  }
  total *= mod_int(K).pow(N - different);
  cout << total << '\n';
}
