Count of arrays having consecutive element with different values
Last Updated :
13 Sep, 2023
Given three positive integers n, k and x. The task is to count the number of different array that can be formed of size n such that each element is between 1 to k and two consecutive element are different. Also, the first and last elements of each array should be 1 and x respectively.
Examples :
Input : n = 4, k = 3, x = 2
Output : 3
The idea is to use Dynamic Programming and combinatorics to solve the problem.
First of all, notice that the answer is same for all x from 2 to k. It can easily be proved. This will be useful later on.
Let the state f(i) denote the number of ways to fill the range [1, i] of array A such that A1 = 1 and Ai ? 1.
Therefore, if x ? 1, the answer to the problem is f(n)/(k – 1), because f(n) is the number of way where An is filled with a number from 2 to k, and the answer are equal for all such values An, so the answer for an individual value is f(n)/(k – 1).
Otherwise, if x = 1, the answer is f(n – 1), because An – 1 ? 1, and the only number we can fill An with is x = 1.
Now, the main problem is how to calculate f(i). Consider all numbers that Ai – 1 can be. We know that it must lie in [1, k].
- If Ai – 1 ? 1, then there are (k – 2)f(i – 1) ways to fill in the rest of the array, because Ai cannot be 1 or Ai – 1 (so we multiply with (k – 2)), and for the range [1, i – 1], there are, recursively, f(i – 1) ways.
- If Ai – 1 = 1, then there are (k – 1)f(i – 2) ways to fill in the rest of the array, because Ai – 1 = 1 means Ai – 2 ? 1 which means there are f(i – 2)ways to fill in the range [1, i – 2] and the only value that Ai cannot be 1, so we have (k – 1) choices for Ai.
By combining the above, we get
f(i) = (k - 1) * f(i - 2) + (k - 2) * f(i - 1)
This will help us to use dynamic programming using f(i).
Below is the implementation of this approach:
C++
#include <bits/stdc++.h>
#define MAXN 109
using namespace std;
int countarray( int n, int k, int x)
{
int dp[MAXN] = { 0 };
dp[0] = 0;
dp[1] = 1;
for ( int i = 2; i < n; i++)
dp[i] = (k - 2) * dp[i - 1] +
(k - 1) * dp[i - 2];
return (x == 1 ? (k - 1) * dp[n - 2] : dp[n - 1]);
}
int main()
{
int n = 4, k = 3, x = 2;
cout << countarray(n, k, x) << endl;
return 0;
}
|
Java
import java.util.*;
class Counting
{
static int MAXN = 109 ;
public static int countarray( int n, int k,
int x)
{
int [] dp = new int [ 109 ];
dp[ 0 ] = 0 ;
dp[ 1 ] = 1 ;
for ( int i = 2 ; i < n; i++)
dp[i] = (k - 2 ) * dp[i - 1 ] +
(k - 1 ) * dp[i - 2 ];
return (x == 1 ? (k - 1 ) * dp[n - 2 ] :
dp[n - 1 ]);
}
public static void main(String[] args)
{
int n = 4 , k = 3 , x = 2 ;
System.out.println(countarray(n, k, x));
}
}
|
Python3
def countarray( n , k , x ):
dp = list ()
dp.append( 0 )
dp.append( 1 )
i = 2
while i < n:
dp.append( (k - 2 ) * dp[i - 1 ] +
(k - 1 ) * dp[i - 2 ])
i = i + 1
return ( (k - 1 ) * dp[n - 2 ] if x = = 1 else dp[n - 1 ])
n = 4
k = 3
x = 2
print (countarray(n, k, x))
|
C#
using System;
class GFG
{
public static int countarray( int n, int k,
int x)
{
int [] dp = new int [109];
dp[0] = 0;
dp[1] = 1;
for ( int i = 2; i < n; i++)
dp[i] = (k - 2) * dp[i - 1] +
(k - 1) * dp[i - 2];
return (x == 1 ? (k - 1) * dp[n - 2] :
dp[n - 1]);
}
public static void Main()
{
int n = 4, k = 3, x = 2;
Console.WriteLine(countarray(n, k, x));
}
}
|
Javascript
<script>
let MAXN = 109;
function countarray(n, k, x)
{
let dp = [];
dp[0] = 0;
dp[1] = 1;
for (let i = 2; i < n; i++)
dp[i] = (k - 2) * dp[i - 1] +
(k - 1) * dp[i - 2];
return (x == 1 ? (k - 1) * dp[n - 2] :
dp[n - 1]);
}
let n = 4, k = 3, x = 2;
document.write(countarray(n, k, x));
</script>
|
PHP
<?php
$MAXN = 109;
function countarray( $n , $k , $x )
{
$dp = array ( 0 );
$dp [0] = 0;
$dp [1] = 1;
for ( $i = 2; $i < $n ; $i ++)
$dp [ $i ] = ( $k - 2) * $dp [ $i - 1] +
( $k - 1) * $dp [ $i - 2];
return ( $x == 1 ? ( $k - 1) *
$dp [ $n - 2] : $dp [ $n - 1]);
}
$n = 4; $k = 3; $x = 2;
echo countarray( $n , $k , $x ) ;
?>
|
Time Complexity: O(n)
Auxiliary Space: O(MAXN), here MAXN = 109
Efficient approach: Space optimization O(1)
In the approach we have only used three variables , prev1 and prev2 to store the values of the previous two elements of the dp array and curr to store the current value. Therefore, the space complexity of the optimized code is O(1)
Implementation Steps:
- Create 2 variables prev1 and prev2 to keep track of the previous 2 values of DP and curr to store the current value.
- Initialize prev1 and prev2 with 0 and 1 as base cases.
- Now iterate through loop and get the current value form previous 2 values.
- after Every iteration assign prev2 to prev1 and curr to prev2 to iterate further;
- At last return answer.
Implementation:
C++
#include <bits/stdc++.h>
#define MAXN 109
using namespace std;
int countarray( int n, int k, int x)
{
int prev1 = 0, prev2 = 1, curr;
for ( int i = 2; i < n; i++) {
curr = (k - 2) * prev2 + (k - 1) * prev1;
prev1 = prev2;
prev2 = curr;
}
return (x == 1 ? (k - 1) * prev1 : prev2);
}
int main()
{
int n = 4, k = 3, x = 2;
cout << countarray(n, k, x) << endl;
return 0;
}
|
Java
import java.util.*;
public class Main {
static int countArray( int n, int k, int x)
{
int prev1 = 0 , prev2 = 1 , curr;
for ( int i = 2 ; i < n; i++) {
curr = (k - 2 ) * prev2 + (k - 1 ) * prev1;
prev1 = prev2;
prev2 = curr;
}
return (x == 1 ? (k - 1 ) * prev1 : prev2);
}
public static void main(String[] args)
{
int n = 4 , k = 3 , x = 2 ;
System.out.println(countArray(n, k, x));
}
}
|
Python3
def countarray(n, k, x):
prev1 = 0
prev2 = 1
for i in range ( 2 , n):
curr = (k - 2 ) * prev2 + (k - 1 ) * prev1
prev1 = prev2
prev2 = curr
return (k - 1 ) * prev1 if x = = 1 else prev2
n = 4
k = 3
x = 2
print (countarray(n, k, x))
|
C#
using System;
public class Program
{
public static int CountArray( int n, int k, int x)
{
int prev1 = 0, prev2 = 1, curr;
for ( int i = 2; i < n; i++) {
curr = (k - 2) * prev2 + (k - 1) * prev1;
prev1 = prev2;
prev2 = curr;
}
return (x == 1 ? (k - 1) * prev1 : prev2);
}
public static void Main()
{
int n = 4, k = 3, x = 2;
Console.WriteLine(CountArray(n, k, x));
}
}
|
Javascript
function countArray(n, k, x) {
let prev1 = 0, prev2 = 1, curr;
for (let i = 2; i < n; i++) {
curr = (k - 2) * prev2 + (k - 1) * prev1;
prev1 = prev2;
prev2 = curr;
}
return (x === 1 ? (k - 1) * prev1 : prev2);
}
let n = 4, k = 3, x = 2;
console.log(countArray(n, k, x));
|
Time Complexity: O(n)
Auxiliary Space: O(1)
Share your thoughts in the comments
Please Login to comment...