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 Java (OpenJDK 1.8.0) (judge verdict: Accepted)

import java.io.*;
import java.math.*;
import java.util.*;
public class Main { 

	public static void main(String[] args) { //Write choose function for each k (0 <= k <= N-1)
		//Figure out why this even works to begin with (why no overcounting occurs)
		Scanner input = new Scanner(System.in);
		long N = input.nextLong();
		long M = input.nextLong();
		long K = input.nextLong();
		long[][] fact = new long[(int) (N+1)][2]; //[Factorial][Inverse]
		fact[1][0]=1;
		fact[1][1]=1;
		long mod = 998244353;
		long baseCase = M;
		baseCase*=FastExp(M-1,N-1,mod);
		baseCase%=mod; //K=0 case
		long ans = baseCase;
		for (long i = 2; i <= N; i++) { //Pre-computing factorial and inverses
			fact[(int) i][0] = fact[(int) (i-1)][0]*i;
			fact[(int) i][0]%=mod;
			long inverse = FastExp(fact[(int) i][0],mod-2,mod);
			fact[(int) i][1] = inverse;
		}
		for (long i = 1; i <= K; i++) {
			if (K==N-1) {
				ans = FastExp(M,N,mod); //Avoiding finding factorial of 0 (dubious case that is hard to code using choose function)
				break;
			}else {
				long curans = M; //M ways of making pairs same color
				long pairs = fact[(int) (N-1)][0];
				pairs*=fact[(int) i][1];
				pairs%=mod;
				pairs*=fact[(int)(N-i-1)][1]; //Choosing K pairs from N-1 adjacent pair slots
				pairs%=mod;
				curans*=pairs;
				curans%=mod; //Each pair has M possibilities
				//K pairs = K+1 slots used, therefore N-(K+1) = N-K-1 slots remain (1<=i<=K)
				long leftover = FastExp(M-1,N-i-1,mod);
				curans*=leftover;
				curans%=mod;
				ans+=curans;
				ans%=mod;
			}
		}
		System.out.println(ans);
	}
	public static long FastExp(long base, long exp, long mod) {
		long ans = 1;
		while (exp>0) {
			if (exp%2==1) ans*=base;
			base*=base;
			base%=mod;
			ans%=mod;
			exp/=2;
		}
		return ans;
	}
}