在给定约束下，排列N个数字的方式数(范围从1到K)。

给定四个整数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)。

如果您希望与行业专家一起参加现场课程，请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。