给定四个整数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 } - 仔细观察可能会注意到:
- A[i] = B[i-1]
原因 :
所有有利节点(以 Q 结尾)只会由前一级别的不利节点(不以 Q 结尾)产生。 - 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。
- A[i] = B[i-1]
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)。