Problem:
Score : 500 points

Problem Statement

There are N blocks arranged in a row. Let us paint these blocks.

We will consider two ways to paint the blocks different if and only if there is a block painted in different colors in those two ways.

Find the number of ways to paint the blocks under the following conditions:

For each block, use one of the M colors, Color 1 through Color M, to paint it. It is not mandatory to use all the colors.

There may be at most K pairs of adjacent blocks that are painted in the same color.

Since the count may be enormous, print it modulo 998244353.

Constraints

All values in input are integers.

1 \leq N, M \leq 2 \times 10^5

0 \leq K \leq N - 1

Input

Input is given from Standard Input in the following format:

N M K

Output

Print the answer.

Sample Input 1

3 2 1

Sample Output 1

6

The following ways to paint the blocks satisfy the conditions: 112, 121, 122, 211, 212, and 221. Here, digits represent the colors of the blocks.

Sample Input 2

100 100 0

Sample Output 2

73074801

Sample Input 3

60522 114575 7559

Sample Output 3

479519525

Solution in C (GCC 9.2.1) (judge verdict: Accepted)

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h> // uint64_t

#define max(a,b) ((a) > (b) ? (a) : (b))
#define min(a,b) ((a) > (b) ? (b) : (a))

int get_int3(int *a1, int *a2, int *a3) {
  scanf("%d %d %d", a1, a2, a3);
  return 0;
}
#define NUM_MAX 200000
#define COLOR_MAX 200000
#define DIVISOR 998244353

static int64_t factorial[NUM_MAX*2];
static int64_t inv_factorial[NUM_MAX*2];
static int64_t power_of_c[NUM_MAX+1];

struct pair {
    int x;
    int y;
};

struct pair gcdext(int a, int b) {
    if(a==0) { return (struct pair){0, 1}; }
    struct pair p = gcdext(b%a, a);
    return (struct pair){ p.y - (b/a)*p.x , p.x };
}

void init(int colors) {
    factorial[0] = factorial[1] = 1;
    inv_factorial[0] = inv_factorial[1] = 1;
    int i;
    for(i = 2; i < NUM_MAX*2; i++) {
        factorial[i] = (factorial[i-1]*i)%DIVISOR;
        struct pair p = gcdext(i, DIVISOR);
        int inv = (p.x+DIVISOR)%DIVISOR;
        inv_factorial[i] = (inv_factorial[i-1]*inv)%DIVISOR;
    }
    power_of_c[0] = 1;
    for(i = 1; i <= NUM_MAX; i++) {
        power_of_c[i] = (power_of_c[i-1] * (colors-1))%DIVISOR;
    }
    return;
}

int64_t calc_combi(int n, int k) {
    int64_t ans = 1;
    ans = (ans * factorial[n])%DIVISOR;
    ans = (ans * inv_factorial[n-k])%DIVISOR;
    ans = (ans * inv_factorial[k])%DIVISOR;
    return ans;
}

int main(void) {
    int num, colors, tlimit;
    get_int3(&num, &colors, &tlimit);
    int64_t ans = 0;
    init(colors);

    int k;
    for(k = 0; k <= tlimit; k++) {
        int64_t res = colors;
        int types = num-k;
        res = ( res * power_of_c[types-1] )%DIVISOR;
        res = (res * calc_combi(num-1, num-types))%DIVISOR;
#ifdef DEBUG
        printf("%d -> %lld\n", k, res);
#endif
        ans = (ans + res)%DIVISOR;
    }

    printf("%d\n", (int)ans);
    return 0;
}