给定数组arr []由[0，M]范围内的N个整数和一个整数M组成，任务是计算用范围[[]中的非零值)替换值为0的所有数组元素的方式数量0，M]，这样所有可能的M个连续元素都是不同的。
例子：
Input: arr[] = { 1, 0, 3, 0, 0 }, M = 4
Output: 2
Explanation:
Possible ways to replace arr[1], arr[3] and arr[4] with non-zero values such that no M( = 4) consecutive elements contains any duplicate elements are { { 1, 2, 3, 4, 1 }, { 1, 4, 3, 2, 1 } }.
Therefore, the required output is 2.
Input: arr[] = {0, 1, 2, 1, 0}, M = 4
Output: 0
Explanation:No such arrangements possible.
方法：想法是将0 s替换为非零元素，以使arr [i]必须等于arr [i％M] 。请按照以下步骤解决问题：
- 初始化大小为M +1的数组B [] ，以存储M个连续的数组数组元素，以使arr [i]等于B [i％M] 。
- 遍历数组并检查以下条件：
- 如果arr [i]不为0并且B [i％M]为0 ，则B [i％M]将等于arr [i]，因为此数字应原样存在。
- 如果arr [i]不等于B [i％M] ，则打印0，因为不存在这样的安排。
- 计算数组B []中的0 s计数，例如X。
- 然后，存在阶乘X的可能布置，因此，打印阶乘X的值。
下面是上述方法的实现：
C++
// C++ program for the above approach
#include
using namespace std;
// Modular function
// to calculate factorial
long long int Fact(int N)
{
// Stores factorial of N
long long int result = 1;
// Iterate over the range [1, N]
for (int i = 1; i <= N; i++) {
// Update result
result = (result * i);
}
return result;
}
// Function to count ways to replace array
// elements having 0s with non-zero elements
// such that any M consective elements are distinct
void numberOfWays(int M, int arr[], int N)
{
// Store m consective distinct elements
// such that arr[i] is equal to B[i % M]
int B[M] = { 0 };
// Stores frequency of array elements
int counter[M + 1] = { 0 };
// Traverse the array arr[]
for (int i = 0; i < N; i++) {
// If arr[i] is non-zero
if (arr[i] != 0) {
// If B[i % M] is equal to 0
if (B[i % M] == 0) {
// Update B[i % M]
B[i % M] = arr[i];
// Update frequency of arr[i]
counter[arr[i]]++;
// If a duplicate element found
// in M consective elements
if (counter[arr[i]] > 1) {
cout << 0 << endl;
return;
}
}
// Handling the case of
// inequality
else if (B[i % M] != arr[i]) {
cout << 0 << endl;
return;
}
}
}
// Stores count of 0s
// in B[]
int cnt = 0;
// Traverse the array, B[]
for (int i = 0; i < M; i++) {
// If B[i] is 0
if (B[i] == 0) {
// Update cnt
cnt++;
}
}
// Calculate factorial
cout << Fact(cnt) << endl;
}
// Driver Code
int main()
{
// Given M
int M = 4;
// Given array
int arr[] = { 1, 0, 3, 0, 0 };
// Size of the array
int N = sizeof(arr) / sizeof(arr[0]);
// Function Call
numberOfWays(M, arr, N);
} Java
// Java program for the above approach
import java.io.*;
class GFG{
// Modular function
// to calculate factorial
static int Fact(int N)
{
// Stores factorial of N
int result = 1;
// Iterate over the range [1, N]
for(int i = 1; i <= N; i++)
{
// Update result
result = (result * i);
}
return result;
}
// Function to count ways to replace array
// elements having 0s with non-zero elements
// such that any M consective elements are distinct
static void numberOfWays(int M, int[] arr, int N)
{
// Store m consective distinct elements
// such that arr[i] is equal to B[i % M]
int[] B = new int[M];
// Stores frequency of array elements
int[] counter = new int[M + 1];
// Traverse the array arr[]
for(int i = 0; i < N; i++)
{
// If arr[i] is non-zero
if (arr[i] != 0)
{
// If B[i % M] is equal to 0
if (B[i % M] == 0)
{
// Update B[i % M]
B[i % M] = arr[i];
// Update frequency of arr[i]
counter[arr[i]]++;
// If a duplicate element found
// in M consective elements
if (counter[arr[i]] > 1)
{
System.out.println(0);
return;
}
}
// Handling the case of
// inequality
else if (B[i % M] != arr[i])
{
System.out.println(0);
return;
}
}
}
// Stores count of 0s
// in B[]
int cnt = 0;
// Traverse the array, B[]
for(int i = 0; i < M; i++)
{
// If B[i] is 0
if (B[i] == 0)
{
// Update cnt
cnt++;
}
}
// Calculate factorial
System.out.println(Fact(cnt));
}
// Driver Code
public static void main(String[] args)
{
// Given M
int M = 4;
// Given array
int[] arr = new int[]{ 1, 0, 3, 0, 0 };
// Size of the array
int N = arr.length;
// Function Call
numberOfWays(M, arr, N);
}
}
// This code is contributed by Dharanendra L VPython3
# Python3 program for the above approach
# Modular function
# to calculate factorial
def Fact(N):
# Stores factorial of N
result = 1
# Iterate over the range [1, N]
for i in range(1, N + 1):
# Update result
result = (result * i)
return result
# Function to count ways to replace array
# elements having 0s with non-zero elements
# such that any M consective elements are distinct
def numberOfWays(M, arr, N):
# Store m consective distinct elements
# such that arr[i] is equal to B[i % M]
B = [0] * (M)
# Stores frequency of array elements
counter = [0] * (M + 1)
# Traverse the array arr
for i in range(0, N):
# If arr[i] is non-zero
if (arr[i] != 0):
# If B[i % M] is equal to 0
if (B[i % M] == 0):
# Update B[i % M]
B[i % M] = arr[i]
# Update frequency of arr[i]
counter[arr[i]] += 1
# If a duplicate element found
# in M consective elements
if (counter[arr[i]] > 1):
print(0)
return
# Handling the case of
# inequality
elif (B[i % M] != arr[i]):
print(0)
return
# Stores count of 0s
# in B
cnt = 0
# Traverse the array, B
for i in range(0, M):
# If B[i] is 0
if (B[i] == 0):
# Update cnt
cnt += 1
# Calculate factorial
print(Fact(cnt))
# Driver Code
if __name__ == '__main__':
# Given M
M = 4
# Given array
arr = [ 1, 0, 3, 0, 0 ]
# Size of the array
N = len(arr)
# Function Call
numberOfWays(M, arr, N)
# This code is contributed by shikhasingrajputC#
// C# program for the above approach
using System;
class GFG{
// Modular function
// to calculate factorial
static int Fact(int N)
{
// Stores factorial of N
int result = 1;
// Iterate over the range [1, N]
for(int i = 1; i <= N; i++)
{
// Update result
result = (result * i);
}
return result;
}
// Function to count ways to replace array
// elements having 0s with non-zero elements
// such that any M consective elements are distinct
static void numberOfWays(int M, int[] arr, int N)
{
// Store m consective distinct elements
// such that arr[i] is equal to B[i % M]
int[] B = new int[M];
// Stores frequency of array elements
int[] counter = new int[M + 1];
// Traverse the array arr[]
for(int i = 0; i < N; i++)
{
// If arr[i] is non-zero
if (arr[i] != 0)
{
// If B[i % M] is equal to 0
if (B[i % M] == 0)
{
// Update B[i % M]
B[i % M] = arr[i];
// Update frequency of arr[i]
counter[arr[i]]++;
// If a duplicate element found
// in M consective elements
if (counter[arr[i]] > 1)
{
Console.WriteLine(0);
return;
}
}
// Handling the case of
// inequality
else if (B[i % M] != arr[i])
{
Console.WriteLine(0);
return;
}
}
}
// Stores count of 0s
// in B[]
int cnt = 0;
// Traverse the array, B[]
for(int i = 0; i < M; i++)
{
// If B[i] is 0
if (B[i] == 0)
{
// Update cnt
cnt++;
}
}
// Calculate factorial
Console.WriteLine(Fact(cnt));
}
// Driver Code
static public void Main()
{
// Given M
int M = 4;
// Given array
int[] arr = new int[]{ 1, 0, 3, 0, 0 };
// Size of the array
int N = arr.Length;
// Function Call
numberOfWays(M, arr, N);
}
}
// This code is contributed by Dharanendra L V输出：
2时间复杂度： O(N)
辅助空间： O(N)