在给定的约束下排列从 1 到 K 范围内的 N 个数字的方法数。

给定四个整数N 、 K 、 P和Q 。任务是计算排列从 1 到 K 范围内的 N 个数字的方法的数量，使得第一个数字是 P，最后一个数字是 Q，并且没有两个相邻的数字是连续的。
例子：

Input:  N = 4, K = 3, P = 2, Q = 3 
Output: 3
Explanation:
For N=4, K=3, P=2, Q=3,
ways are [2, 1, 2, 3], [2, 3, 1, 3], [2, 3, 2, 3]

Input:  N = 5, K = 3, P = 2, Q = 1 
Output: 5

方法：思路是用动态规划来解决这个问题。

• 让我们试着通过一个例子来理解这一点，N = 4，K = 3，P = 2，Q = 1。
  我们将从 P 开始观察所有可能的安排，并尝试找到任何对应用动态规划有用的模式。
• 下图显示了从 P = 2 开始的所有可能的排列。
  

• 设 A 是一个数组，其中包含在特定级别以 Q 结尾的节点数
  A = { 0, 1, 1, 3 }
  设 B 是一个数组，它由在特定级别不以 Q 结尾的节点数组成
  B = {1, 1, 3, 5 }
• 仔细观察可能会注意到：
  1. A[i] = B[i-1]
     原因 ：
     所有有利节点(以 Q 结尾)只会由前一级别的不利节点(不以 Q 结尾)产生。
  2. B[i] = A[i-1]*(K – 1) + B[i-1]*(K – 2)
     原因 ：
     • 对于A[i-1]*(K – 1)，一些不利节点是由上一层有利节点产生的，乘以(K – 1)，因为每个有利节点都会产生K-1不利节点节点
     • 对于 B[i-1]*(K – 2)，其余的不利节点由前一层的不利节点产生，乘以 (K-2)，因为产生的节点是有利的，所以我们从中减去2。

C++

// C++ program to calculate Number of 
// ways to arrange N numbers under
// given constraints.
#include 
using namespace std;
  
class element {
public:
    // For favourable nodes 
    // (ending at Q)
    int A;
      
    // For Non-favourable nodes
    // (NOT ending at Q)
    int B;
};
  
// Function to print Total number
// of ways
void NumberOfWays(int n, int k, int p, 
                                int q)
{
    element* dp = new element[n];
  
    // If the First number and the
    // last number is same.
    if (p == q) {
        dp[0].A = 1;
        dp[0].B = 0;
    }
    else
    {
        dp[0].A = 0;
        dp[0].B = 1;
    }
  
    // DP approach to find current state 
    // with the help of previous state.
    for (int i = 1; i < n; i++)
    {
        dp[i].A = dp[i - 1].B;
        dp[i].B = (dp[i - 1].A * (k - 1))
                 + (dp[i - 1].B * (k - 2));
    }
      
    cout << dp[n - 1].A << endl;
  
    return;
}
  
// Driver code
int main()
{
     
   int N = 5;
   int K = 3;
   int P = 2;
   int Q = 1;
      
   // Function call
   NumberOfWays(N, K, P, Q);
}

Java

// Java program to calculate number of  
// ways to arrange N numbers under 
// given constraints. 
import java.io.*;
import java.util.*; 
  
class GFG{
  
// Function to print Total number 
// of ways 
static void NumberOfWays(int n, int k, 
                         int p, int q) 
{ 
    int[][] dp = new int[n][2]; 
  
    // If the First number and the 
    // last number is same. 
    if (p == q) 
    { 
        dp[0][0] = 1; 
        dp[0][1] = 0; 
    } 
    else
    { 
        dp[0][0] = 0; 
        dp[0][1] = 1; 
    } 
  
    // DP approach to find current state 
    // with the help of previous state. 
    for(int i = 1; i < n; i++) 
    { 
        dp[i][0] = dp[i - 1][1]; 
        dp[i][1] = (dp[i - 1][0] * (k - 1)) +
                   (dp[i - 1][1] * (k - 2)); 
    } 
    System.out.println(dp[n - 1][0]); 
} 
  
// Driver Code 
public static void main(String args[]) 
{ 
    int N = 5; 
    int K = 3; 
    int P = 2; 
    int Q = 1; 
          
    // Function call 
    NumberOfWays(N, K, P, Q); 
}
} 
  
// This code is contributed by offbeat

输出：

5

时间复杂度： O(N)。