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: Wrong Answer)

#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define ld long double
#define pb push_back
#define mp make_pair

const int MAXN=205;
const ll inf = 1e18;
//const ll mod=1000000007;
ll mod=998244353;

typedef pair<ll,ll> pi;

ll gc(ll a,ll b)
{
    if(b==0) return a;
    return gc(b,a%b);
}
ll power(ll x, ll y, ll p)
{
    ll res = 1;     // Initialize result

    x = x % p; // Update x if it is more than or
                // equal to p

    if (x == 0) return 0; // In case x is divisible by p;

    while (y > 0)
    {
        // If y is odd, multiply x with result
        if (y & 1)
            res = (res*x) % p;

        // y must be even now
        y = y>>1; // y = y/2
        x = (x*x) % p;
    }
    return res;
}

vector<bool>prime(1000005,true);
vector<ll>v;
void sieve(ll n)
{
    prime[1]=false;
   for (int p=2; p*p<=n; p++)
    {
        // If prime[p] is not changed, then it is a prime
        if (prime[p] == true)
        {
            // Update all multiples of p greater than or
            // equal to the square of it
            // numbers which are multiple of p and are
            // less than p^2 are already been marked.
            for (int i=p*p; i<=n; i += p)
                prime[i] = false;
        }
    }

    for(int i=2;i<=n;i++)
    {
        if(prime[i]==true)
            v.push_back(i);
    }
}

int BIT[1000];
void update(int x, int delta)
{
    int n;
      for(; x <= n; x += x&-x)
        BIT[x] += delta;
}
int query(int x)
{
     int sum = 0;
     for(; x > 0; x -= x&-x)
        sum += BIT[x];
     return sum;
}


inline ll add(ll a,ll b) {return ((a%mod)+(b%mod))%mod;}
inline ll sub(ll a,ll b) {return ((a%mod)-(b%mod)+mod)%mod;}
inline ll mul(ll a,ll b) {return ((a%mod)*(b%mod))%mod;}


ll recur(ll idx,ll sum, vector<pair<ll,ll> >& v, vector<ll>& b, vector<ll>& pre, vector<ll>& dp)
{
    if(idx==b.size()) return 0;
    if(dp[idx]!=-1) return dp[idx];
    ll temp=INT_MAX;
    temp=min(temp,recur(idx+1,sum,v,b,pre,dp) + b[idx]);
    for(int i=0;i<v.size();i++)
    {
        ll x=v[i].first;
        ll y=v[i].second;
        if(idx+x-1>=b.size()) continue;
        ll calc= pre[idx+x-1]-pre[idx+y-1];
        temp=min(temp, recur(idx+x, sum,v,b,pre,dp)+ calc);
    }
    dp[idx]=temp;
    return temp;
}


ll find(ll u, vector<ll>& parent)
{
    if(u==parent[u]) return u;
    else return parent[u]=find(parent[u],parent);
}
 void unio(ll u, ll v, vector<ll>& parent, vector<ll>& ran)
{
    u=find(u,parent);
    v=find(v,parent);
    if(u==v) return;
    if(ran[u]>=ran[v])
    {
        parent[v]=u;
        ran[u]+=ran[v];
    }
    else{
        parent[u]=v;
        ran[v]+=ran[u];
    }
}
ll dfs(ll src, ll p, vector<ll>& a, vector<pair<ll,ll> > adj[], vector<ll>& dp)
{
    ll can1=0;
    ll can2=0;
    vector<pair<ll,ll> >:: iterator it;
    for(it=adj[src].begin();it!=adj[src].end();it++)
    {
        if(((*it).first==p)) continue;
        ll st=max(0LL,dfs((*it).first,src,a,adj,dp)- (*it).second);
        if(st>can1)
        {
            can2=can1;
            can1=st;
        }
        else if(st>can2)
        {
            can2=st;
        }
    }
    dp[src]=a[src]+ can1+can2;
    return (max(can1,can2)+ a[src]);
}
/*  FINDING LCS IN (NLOGN) COMPLEXITY
int n;
	cin >> n;
	vector<int> a(n);
	for (int i = 0; i < n; i++) {
		cin >> a[i];
	}
	vector<int> d(n+1, 1000000000);
	for (int i = 0; i < n; i++) {
		*lower_bound(d.begin(), d.end(), a[i]) = a[i];
	}
	for (int i = 0; i <= n; i++) {
		if (d[i] == 1000000000) {
			cout << i << endl;
			return 0;
		}
	}
*/
struct comp1{
    bool operator ()(pair<ll,ll>& temp1, pair<ll,ll>& temp2)
{

}
};
bool comp2(pair<ll,ll>& temp1, pair<ll,ll>& temp2)
{
    return temp1.second<temp2.second;
}

ll getinv(ll temp)
{
    return power(temp,mod-2,mod);

}

int main()
{
/*
  ll n;
  cin>>n;
  string s[n];
  for(ll i=0;i<n;i++) cin>>s[i];
  vector<pair<ll,ll> >v;
  for(ll i=0;i<n;i++)
  {
      ll b=0;
      ll temp=0;
      ll len=s[i].length();
     for(ll j=0;j<s[i].length();)
        {
            if(s[i][j]=='(')
            {
                while(j<len && s[i][j]=='(')
                {
                    b++;
                    j++;
                }
                while(j<len && s[i][j]==')')
                {
                    b--;
                    j++;
                }

            }
            else
            {
                if(b>0)
                {
                    b--;
                    j++;
                }
                else
                {
                    //ll temp=0;
                    while(j<len && s[i][j]==')')
                    {
                        temp--;
                        j++;
                    }
                  //v.pb(temp);
                }
            }

        }
        v.pb(mp(b,temp));
   }
   ll sum1=0;
   ll sum2=0;
 for(ll i=0;i<n;i++)
 {
    // cout<<v[i].first<<" "<<v[i].second<<endl;
     sum1+=abs(v[i].first);
     sum2+=abs(v[i].second);
 }
bool f=true;
//cout<<sum1<<" "<<sum2<<endl;
 for(ll i=0;i<n;i++)
 {
     if(abs(v[i].first)>0)
     {
         sum2-=abs(v[i].second);
         if(sum2<abs(v[i].first))
         {
             f=false;
             break;
         }
        sum2+=abs(v[i].second);

     }
     if(abs(v[i].second)>0)
     {
         sum1-=abs(v[i].first);
         if(sum1<abs(v[i].second))
         {
             f=false;
             break;
         }
        sum1+=abs(v[i].first);

     }
 }
 //cout<<sum1<<" "<<sum2<<" "<<f<<endl;
 if((f==false) || (abs(sum1)!=abs(sum2)))
 cout<<"No";
 else cout<<"Yes";
    */
    ll n,m,k;

    cin>>n>>m>>k;
    vector<ll>fac(n+1);
    vector<ll>inv(n+1);
    fac[0]=1;
    fac[1]=1;
    for(ll i=2;i<=n;i++) fac[i]=mul(fac[i-1],i);
    for(ll i=0;i<=n;i++)
    {
        inv[i]=power(fac[i],mod-2,mod);
    }
    ll ans=0;
    for(ll i=0;i<=k;i++)
    {
        ll temp=mul(fac[n-1],mul(inv[i],inv[n-1-i]));
        temp=mul(temp,m);
        temp=mul(temp,power(m-1,n-1-i,mod));
        ans=add(ans,temp);
    }
    cout<<ans;
}