形成具有不同相邻元素的数组的方法数

给定三个整数 N、M 和 X，任务是找到形成数组的方法数，使得数组的所有连续数都是不同的，并且数组的任何索引处的值从 2 到 N – 1(考虑基于 1 的索引)介于 1 和 M 之间，而索引 1 处的值是 X，索引 N 处的值是 1。
注：X 的值介于 1 和 M 之间。
例子：

Input: N = 4, M = 3, X = 2 
Output: 3 
The following arrays are possible: 
1) 2, 1, 2, 1 
2) 2, 1, 3, 1 
3) 2, 3, 2, 1
Input: N = 2, M = 3, X = 2 
Output: 1 
The only possible array is: 2, 1

方法：该问题可以使用动态规划解决。让 f(i) 表示形成数组的方法数，直到第 i 个索引，这样数组的每个连续元素都是不同的。让 f(i, One) 表示形成数组的方法数，直到第 i 个索引，这样数组的每个连续元素都是不同的并且 arr _i = 1。
类似地，让f(i, Non-One)表示在第 i 个索引之前形成数组的方式数，这样数组的每个连续元素都是不同的，并且 arr _i不等于 1。
形成如下循环：

f(i, Non-One) = f(i - 1, One) * (M - 1) + f(i - 1, Non-One) * (M - 2)

这意味着在数组_i不等于 1 的第 i 个索引之前形成数组的方法数是使用两种情况形成的：

1. 如果数组_{i – 1}处的数字为 1，则从(M – 1) 个选项中选择一个数字放置在第 i^个索引处，因为数组_i不等于 1。
2. 如果数组_{i – 1}中的数字不是 1，那么我们需要从(M – 2) 个选项中选择一个数字，因为数组_i不等于 1 并且数组_i ≠ 数组_{i – 1} 。

类似地， f(i, One) = f(i – 1, Non-One) ，因为在数组_i = 1 的第 i 个索引之前形成数组的方法数与形成数组的方法数相同，直到数组_{i – 1} ≠ 1 的第 (i – 1) 个索引，因此在第 i^个索引处只有一个选项。最后需要的答案 if f(N, One) 因为数组_N需要等于 1。
下面是上述方法的实现：

C++

// C++ program to count the number of ways
// to form arrays of N numbers such that the
// first and last numbers are fixed
// and all consecutive numbers are distinct
#include 
using namespace std;
 
// Returns the total ways to form arrays such that
// every consecutive element is different and each
// element except the first and last can take values
// from 1 to M
int totalWays(int N, int M, int X)
{
 
    // define the dp[][] array
    int dp[N + 1][2];
 
    // if the first element is 1
    if (X == 1) {
 
        // there is only one way to place
        // a 1 at the first index
        dp[0][0] = 1;
    }
    else {
 
        // the value at first index needs to be 1,
        // thus there is no way to place a non-one integer
        dp[0][1] = 0;
    }
 
    // if the first element was 1 then at index 1,
    // only non one integer can be placed thus
    // there are M - 1 ways to place a non one integer
    // at index 2 and 0 ways to place a 1 at the 2nd index
    if (X == 1) {
        dp[1][0] = 0;
        dp[1][1] = M - 1;
    }
 
    // Else there is one way to place a one at
    // index 2 and if a non one needs to be placed here,
    // there are (M - 2) options, i.e
    // neither the element at this index
    // should be 1, neither should it be
    // equal to the previous element
    else {
        dp[1][0] = 1;
        dp[1][1] = (M - 2);
    }
 
    // Build the dp array in bottom up manner
    for (int i = 2; i < N; i++) {
 
        // f(i, one) = f(i - 1, non-one)
        dp[i][0] = dp[i - 1][1];
 
        // f(i, non-one) = f(i - 1, one) * (M - 1) +
        // f(i - 1, non-one) * (M - 2)
        dp[i][1] = dp[i - 1][0] * (M - 1) + dp[i - 1][1] * (M - 2);
    }
 
    // last element needs to be one, so return dp[n - 1][0]
    return dp[N - 1][0];
}
 
// Driver Code
int main()
{
 
    int N = 4, M = 3, X = 2;
    cout << totalWays(N, M, X) << endl;
 
    return 0;
}

Java

// Java program to count the
// number of ways to form
// arrays of N numbers such
// that the first and last
// numbers are fixed and all
// consecutive numbers are
// distinct
import java.io.*;
 
class GFG
{
 
// Returns the total ways to
// form arrays such that every
// consecutive element is
// different and each element
// except the first and last
// can take values from 1 to M
static int totalWays(int N,
                     int M, int X)
{
 
    // define the dp[][] array
    int dp[][] = new int[N + 1][2];
 
    // if the first element is 1
    if (X == 1)
    {
 
        // there is only one
        // way to place a 1
        // at the first index
        dp[0][0] = 1;
    }
    else
    {
 
        // the value at first index
        // needs to be 1, thus there
        // is no way to place a
        // non-one integer
        dp[0][1] = 0;
    }
 
    // if the first element was 1
    // then at index 1, only non
    // one integer can be placed
    // thus there are M - 1 ways
    // to place a non one integer
    // at index 2 and 0 ways to
    // place a 1 at the 2nd index
    if (X == 1)
    {
        dp[1][0] = 0;
        dp[1][1] = M - 1;
    }
 
    // Else there is one way to
    // place a one at index 2
    // and if a non one needs to
    // be placed here, there are
    // (M - 2) options, i.e neither
    // the element at this index
    // should be 1, neither should
    // it be equal to the previous
    // element
    else
    {
        dp[1][0] = 1;
        dp[1][1] = (M - 2);
    }
 
    // Build the dp array
    // in bottom up manner
    for (int i = 2; i < N; i++)
    {
 
        // f(i, one) = f(i - 1,
        // non-one)
        dp[i][0] = dp[i - 1][1];
 
        // f(i, non-one) =
        // f(i - 1, one) * (M - 1) +
        // f(i - 1, non-one) * (M - 2)
        dp[i][1] = dp[i - 1][0] * (M - 1) +
                   dp[i - 1][1] * (M - 2);
    }
 
    // last element needs to be
    // one, so return dp[n - 1][0]
    return dp[N - 1][0];
}
 
// Driver Code
public static void main (String[] args)
{
    int N = 4, M = 3, X = 2;
    System.out.println(totalWays(N, M, X));
}
}
 
// This code is contributed by anuj_67.

Python3

# Python 3 program to count the number of ways
# to form arrays of N numbers such that the
# first and last numbers are fixed
# and all consecutive numbers are distinct
 
# Returns the total ways to form arrays such that
# every consecutive element is different and each
# element except the first and last can take values
# from 1 to M
def totalWays(N,M,X):
     
    # define the dp[][] array
    dp = [[0 for i in range(2)] for j in range(N+1)]
 
    # if the first element is 1
    if (X == 1):
         
        # there is only one way to place
        # a 1 at the first index
        dp[0][0] = 1
 
    else:
        # the value at first index needs to be 1,
        # thus there is no way to place a non-one integer
        dp[0][1] = 0
 
    # if the first element was 1 then at index 1,
    # only non one integer can be placed thus
    # there are M - 1 ways to place a non one integer
    # at index 2 and 0 ways to place a 1 at the 2nd index
    if (X == 1):
        dp[1][0] = 0
        dp[1][1] = M - 1
 
    # Else there is one way to place a one at
    # index 2 and if a non one needs to be placed here,
    # there are (M - 2) options, i.e
    # neither the element at this index
    # should be 1, neither should it be
    # equal to the previous element
    else:
        dp[1][0] = 1
        dp[1][1] = (M - 2)
 
    # Build the dp array in bottom up manner
    for i in range(2,N):
        # f(i, one) = f(i - 1, non-one)
        dp[i][0] = dp[i - 1][1]
 
        # f(i, non-one) = f(i - 1, one) * (M - 1) +
        # f(i - 1, non-one) * (M - 2)
        dp[i][1] = dp[i - 1][0] * (M - 1) + dp[i - 1][1] * (M - 2)
 
    # last element needs to be one, so return dp[n - 1][0]
    return dp[N - 1][0]
 
# Driver Code
if __name__ == '__main__':
    N = 4
    M = 3
    X = 2
    print(totalWays(N, M, X))
     
# This code is contributed by
# Surendra_Gangwar

C#

// C# program to count the
// number of ways to form
// arrays of N numbers such
// that the first and last
// numbers are fixed and all
// consecutive numbers are
// distinct
using System;
 
class GFG
{
 
// Returns the total ways to
// form arrays such that every
// consecutive element is
// different and each element
// except the first and last
// can take values from 1 to M
static int totalWays(int N,
                     int M, int X)
{
 
    // define the dp[][] array
    int [,]dp = new int[N + 1, 2];
 
    // if the first element is 1
    if (X == 1)
    {
 
        // there is only one
        // way to place a 1
        // at the first index
        dp[0, 0] = 1;
    }
    else
    {
 
        // the value at first index
        // needs to be 1, thus there
        // is no way to place a
        // non-one integer
        dp[0, 1] = 0;
    }
 
    // if the first element was 1
    // then at index 1, only non
    // one integer can be placed
    // thus there are M - 1 ways
    // to place a non one integer
    // at index 2 and 0 ways to
    // place a 1 at the 2nd index
    if (X == 1)
    {
        dp[1, 0] = 0;
        dp[1, 1] = M - 1;
    }
 
    // Else there is one way to
    // place a one at index 2
    // and if a non one needs to
    // be placed here, there are
    // (M - 2) options, i.e neither
    // the element at this index
    // should be 1, neither should
    // it be equal to the previous
    // element
    else
    {
        dp[1, 0] = 1;
        dp[1, 1] = (M - 2);
    }
 
    // Build the dp array
    // in bottom up manner
    for (int i = 2; i < N; i++)
    {
 
        // f(i, one) = f(i - 1,
        // non-one)
        dp[i, 0] = dp[i - 1, 1];
 
        // f(i, non-one) =
        // f(i - 1, one) * (M - 1) +
        // f(i - 1, non-one) * (M - 2)
        dp[i, 1] = dp[i - 1, 0] * (M - 1) +
                   dp[i - 1, 1] * (M - 2);
    }
 
    // last element needs to be
    // one, so return dp[n - 1][0]
    return dp[N - 1, 0];
}
 
// Driver Code
public static void Main ()
{
    int N = 4, M = 3, X = 2;
    Console.WriteLine(totalWays(N, M, X));
}
}
 
// This code is contributed
// by anuj_67.

Javascript

    // Javascript program to count the
    // number of ways to form
    // arrays of N numbers such
    // that the first and last
    // numbers are fixed and all
    // consecutive numbers are
    // distinct
     
    // Returns the total ways to
    // form arrays such that every
    // consecutive element is
    // different and each element
    // except the first and last
    // can take values from 1 to M
    function totalWays(N, M, X)
    {
 
        // define the dp[][] array
        let dp = new Array(N + 1);
        for(let i = 0; i < N + 1; i++)
        {
            dp[i] = new Array(2);
            for(let j = 0; j < 2; j++)
            {
                dp[i][j] = 0;
            }
        }
 
        // if the first element is 1
        if (X == 1)
        {
 
            // there is only one
            // way to place a 1
            // at the first index
            dp[0][0] = 1;
        }
        else
        {
 
            // the value at first index
            // needs to be 1, thus there
            // is no way to place a
            // non-one integer
            dp[0][1] = 0;
        }
 
        // if the first element was 1
        // then at index 1, only non
        // one integer can be placed
        // thus there are M - 1 ways
        // to place a non one integer
        // at index 2 and 0 ways to
        // place a 1 at the 2nd index
        if (X == 1)
        {
            dp[1][0] = 0;
            dp[1][1] = M - 1;
        }
 
        // Else there is one way to
        // place a one at index 2
        // and if a non one needs to
        // be placed here, there are
        // (M - 2) options, i.e neither
        // the element at this index
        // should be 1, neither should
        // it be equal to the previous
        // element
        else
        {
            dp[1][0] = 1;
            dp[1][1] = (M - 2);
        }
 
        // Build the dp array
        // in bottom up manner
        for (let i = 2; i < N; i++)
        {
 
            // f(i, one) = f(i - 1,
            // non-one)
            dp[i][0] = dp[i - 1][1];
 
            // f(i, non-one) =
            // f(i - 1, one) * (M - 1) +
            // f(i - 1, non-one) * (M - 2)
            dp[i][1] = dp[i - 1][0] * (M - 1) +
                       dp[i - 1][1] * (M - 2);
        }
 
        // last element needs to be
        // one, so return dp[n - 1][0]
        return dp[N - 1][0];
    }
     
    let N = 4, M = 3, X = 2;
    document.write(totalWays(N, M, X));
 
// This code is contributed by divyeshrabadiya07.

输出：

3

时间复杂度： O(N)，其中 N 是数组的大小

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。