使用 M 种颜色为 N 个框着色，使得 K 个框与其左侧的框具有不同的颜色

给定N个排成一行的框和M种颜色。任务是找到使用M种颜色绘制这N 个框的方法的数量，以便恰好有K 个框的颜色与其左侧框的颜色不同。打印此答案模998244353 。
例子：

Input: N = 3, M = 3, K = 0 
Output: 3 
Since the value of K is zero, no box can have a different color from color of the box on its left. Thus, all boxes should be painted with same color and since there are 3 types of colors, so there are total 3 ways. 
Input: N = 3, M = 2, K = 1 
Output: 4 
Let’s number the colors as 1 and 2. Four possible sequences of painting 3 boxes with 1 box having different color from color of box on its left are (1 2 2), (1 1 2), (2 1 1) (2 2 1) 
 

先决条件：动态规划

方法：这个问题可以使用动态规划来解决，其中dp[i][j]将表示使用M种颜色绘制i 个框的方法数量，以便正好有j 个框的颜色与其上框的颜色不同左边。对于除1 ^st之外的每个当前框，我们可以绘制与其左框相同的颜色并求解dp[i – 1][j]或者我们可以用剩余的M – 1颜色绘制它并求解dp[i – 1][j – 1]递归。
下面是上述方法的实现：

C++

// CPP Program to Paint N boxes using M
// colors such that K boxes have color
// different from color of box on its left
#include 
using namespace std;
 
const int M = 1001;
const int MOD = 998244353;
 
int dp[M][M];
 
// This function returns the required number
// of ways where idx is the current index and
// diff is number of boxes having different
// color from box on its left
int solve(int idx, int diff, int N, int M, int K)
{
    // Base Case
    if (idx > N) {
        if (diff == K)
            return 1;
        return 0;
    }
 
    // If already computed
    if (dp[idx][ diff] != -1)
        return dp[idx][ diff];
 
    // Either paint with same color as
    // previous one
    int ans = solve(idx + 1, diff, N, M, K);
 
    // Or paint with remaining (M - 1)
    // colors
    ans += (M - 1) * solve(idx + 1, diff + 1, N, M, K);
 
    return dp[idx][ diff] = ans % MOD;
}
 
// Driver code
int main()
{
    int N = 3, M = 3, K = 0;
    memset(dp, -1, sizeof(dp));
 
    // Multiply M since first box can be
    // painted with any of the M colors and
    // start solving from 2nd box
    cout << (M * solve(2, 0, N, M, K)) << endl;
 
    return 0;
}

Java

// Java Program to Paint N boxes using M
// colors such that K boxes have color
// different from color of box on its left
 
class GFG
{
     
    static int M = 1001;
    static int MOD = 998244353;
 
    static int[][] dp = new int[M][M];
 
    // This function returns the required number
    // of ways where idx is the current index and
    // diff is number of boxes having different
    // color from box on its left
    static int solve(int idx, int diff,
                        int N, int M, int K)
    {
        // Base Case
        if (idx > N)
        {
            if (diff == K)
                return 1;
            return 0;
        }
 
        // If already computed
        if (dp[idx][ diff] != -1)
            return dp[idx][ diff];
 
        // Either paint with same color as
        // previous one
        int ans = solve(idx + 1, diff, N, M, K);
 
        // Or paint with remaining (M - 1)
        // colors
        ans += (M - 1) * solve(idx + 1,
                diff + 1, N, M, K);
 
        return dp[idx][ diff] = ans % MOD;
    }
 
    // Driver code
    public static void main (String[] args)
    {
        int N = 3, M = 3, K = 0;
        for(int i = 0; i <= M; i++)
            for(int j = 0; j <= M; j++)
                dp[i][j] = -1;
     
        // Multiply M since first box can be
        // painted with any of the M colors and
        // start solving from 2nd box
        System.out.println((M * solve(2, 0, N, M, K)));
    }
}
 
// This code is contributed by mits

Python3

# Python3 Program to Paint N boxes using M
# colors such that K boxes have color
# different from color of box on its left
 
M = 1001;
MOD = 998244353;
 
dp = [[-1]* M ] * M
 
# This function returns the required number
# of ways where idx is the current index and
# diff is number of boxes having different
# color from box on its left
def solve(idx, diff, N, M, K) :
     
    # Base Case
    if (idx > N) :
        if (diff == K) :
            return 1
        return 0
 
    # If already computed
    if (dp[idx][ diff] != -1) :
        return dp[idx];
 
    # Either paint with same color as
    # previous one
    ans = solve(idx + 1, diff, N, M, K);
 
    # Or paint with remaining (M - 1)
    # colors
    ans += (M - 1) * solve(idx + 1, diff + 1, N, M, K);
 
    dp[idx][ diff] = ans % MOD;
     
    return dp[idx][ diff]
 
# Driver code
if __name__ == "__main__" :
 
    N = 3
    M = 3
    K = 0
 
    # Multiply M since first box can be
    # painted with any of the M colors and
    # start solving from 2nd box
    print(M * solve(2, 0, N, M, K))
 
# This code is contributed by Ryuga

C#

// C# Program to Paint N boxes using M
// colors such that K boxes have color
// different from color of box on its left
using System;
class GFG
{
     
static int M = 1001;
static int MOD = 998244353;
 
static int[,] dp = new int[M, M];
 
// This function returns the required number
// of ways where idx is the current index and
// diff is number of boxes having different
// color from box on its left
static int solve(int idx, int diff,
                 int N, int M, int K)
{
    // Base Case
    if (idx > N)
    {
        if (diff == K)
            return 1;
        return 0;
    }
 
    // If already computed
    if (dp[idx, diff] != -1)
        return dp[idx, diff];
 
    // Either paint with same color as
    // previous one
    int ans = solve(idx + 1, diff, N, M, K);
 
    // Or paint with remaining (M - 1)
    // colors
    ans += (M - 1) * solve(idx + 1,
                diff + 1, N, M, K);
 
    return dp[idx, diff] = ans % MOD;
}
 
// Driver code
public static void Main ()
{
    int N = 3, M = 3, K = 0;
    for(int i = 0; i <= M; i++)
        for(int j = 0; j <= M; j++)
            dp[i, j] = -1;
 
    // Multiply M since first box can be
    // painted with any of the M colors and
    // start solving from 2nd box
    Console.WriteLine((M * solve(2, 0, N, M, K)));
}
}
 
// This code is contributed by chandan_jnu

PHP

 $N)
    {
        if ($diff == $K)
            return 1;
        return 0;
    }
 
    // If already computed
    if ($dp[$idx][$diff] != -1)
        return $dp[$idx][$diff];
 
    // Either paint with same color
    // as previous one
    $ans = solve($idx + 1, $diff, $N, $M, $K);
 
    // Or paint with remaining (M - 1)
    // colors
    $ans += ($M - 1) * solve($idx + 1,
             $diff + 1, $N, $M, $K);
 
    return $dp[$idx][$diff] = $ans % $MOD;
}
 
// Driver code
$N = 3;
$M = 3;
$K = 0;
 
// Multiply M since first box can be
// painted with any of the M colors and
// start solving from 2nd box
echo ($M * solve(2, 0, $N, $M, $K));
 
// This code is contributed by chandan_jnu
?>

Javascript

 
    // JavaScript Program to Paint N boxes using M
    // colors such that K boxes have color
    // different from color of box on its left
     
    let m = 1001;
    let MOD = 998244353;
   
    let dp = new Array(m);
    for(let i = 0; i < m; i++)
    {
        dp[i] = new Array(m);
        for(let j = 0; j < m; j++)
        {
            dp[i][j] = 0;
        }
    }
   
    // This function returns the required number
    // of ways where idx is the current index and
    // diff is number of boxes having different
    // color from box on its left
    function solve(idx, diff, N, M, K)
    {
        // Base Case
        if (idx > N)
        {
            if (diff == K)
                return 1;
            return 0;
        }
   
        // If already computed
        if (dp[idx][ diff] != -1)
            return dp[idx][ diff];
   
        // Either paint with same color as
        // previous one
        let ans = solve(idx + 1, diff, N, M, K);
   
        // Or paint with remaining (M - 1)
        // colors
        ans += (M - 1) * solve(idx + 1,
                diff + 1, N, M, K);
          dp[idx][ diff] = ans % MOD;
        return dp[idx][ diff];
    }
     
    let N = 3, M = 3, K = 0;
    for(let i = 0; i <= M; i++)
      for(let j = 0; j <= M; j++)
        dp[i][j] = -1;
 
    // Multiply M since first box can be
    // painted with any of the M colors and
    // start solving from 2nd box
    document.write((M * solve(2, 0, N, M, K)));
     

输出：

3