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 11.0.6) (judge verdict: Time Limit Exceeded)

import java.util.*;

public class Main {
    static final long MODVAL = 998244353L;
    static long dp[][];
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int M = sc.nextInt();
        int K = sc.nextInt();
        dp = new long[N+1][2];
        // s番目までのブロックを塗って重複塗りがk回の塗り方はdp[s][k]通りだとする。
        // dp[s+1][k] = dp[s][k] * (M-1) + dp[s][k-1]
        // 1st param: 1 -> N
        // 2nd param: 0 -> K
        dp[1][0] = M;
        long result = 0L;
        for(int k=0; k<=K; k++) {
            int current = k % 2;
            int previous = (k+1) % 2;
            switch(k) {
                case 0:
                    dp[1][current] = M;
                    break;
                case 1:
                    dp[1][current] = 0;
                    dp[1][previous] = M;
                    break;
                default:
                    dp[1][current] = 0;
                    dp[1][previous] = 0;
                    break;
            }
            for(int s=1; s<=N-1; s++) {
                if(k==0) {
                    dp[s+1][current] = (dp[s][current] * (M-1)) % MODVAL;
//                    System.out.println(String.format("dp[%d][%d]=%d", s+1, k, dp[s][current]));
                } else {
                    dp[s+1][current] = (dp[s][current] * (M-1) + dp[s][previous]) % MODVAL;
//                    System.out.println(String.format("dp[%d][%d]=%d", s+1, k, dp[s][current]));
                }
            }
            result = (result + dp[N][current]) % MODVAL;
        }
        System.out.println(result);
    }
}