📌  相关文章
📜  在给定约束下,排列N个数字的方式数(范围从1到K)。

📅  最后修改于: 2021-06-25 11:35:05             🧑  作者: Mango

给定四个整数NKPQ。任务是计算排列从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现场课程美国》。