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 A₁ = 1 and A_i ? 1.
Therefore, if x ? 1, the answer to the problem is f(n)/(k – 1), because f(n) is the number of way where A_n is filled with a number from 2 to k, and the answer are equal for all such values A_n, so the answer for an individual value is f(n)/(k – 1).
Otherwise, if x = 1, the answer is f(n – 1), because A_{n – 1} ? 1, and the only number we can fill A_n with is x = 1.

Now, the main problem is how to calculate f(i). Consider all numbers that A_{i – 1} can be. We know that it must lie in [1, k].

If A_{i – 1} ? 1, then there are (k – 2)f(i – 1) ways to fill in the rest of the array, because A_i cannot be 1 or A_{i – 1} (so we multiply with (k – 2)), and for the range [1, i – 1], there are, recursively, f(i – 1) ways.
If A_{i – 1} = 1, then there are (k – 1)f(i – 2) ways to fill in the rest of the array, because A_{i – 1} = 1 means A_{i – 2} ? 1 which means there are f(i – 2)ways to fill in the range [1, i – 2] and the only value that A_i cannot be 1, so we have (k – 1) choices for A_i.

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++

// CPP Program to find count of arrays.
#include <bits/stdc++.h>
#define MAXN 109
using namespace std;
 
// Return the number of arrays with given constraints.
int countarray(int n, int k, int x)
{
    int dp[MAXN] = { 0 };
 
    // Initialising dp[0] and dp[1].
    dp[0] = 0;
    dp[1] = 1;
 
    // Computing f(i) for each 2 <= i <= n.
    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]);
}
 
// Driven Program
int main()
{
    int n = 4, k = 3, x = 2;
    cout << countarray(n, k, x) << endl;
    return 0;
}

Java

// Java program to find count of arrays.
import java.util.*;
 
class Counting
{
    static int MAXN = 109;
 
    public static int countarray(int n, int k, 
                                       int x)
    {
        int[] dp = new int[109];
 
        // Initialising dp[0] and dp[1].
        dp[0] = 0;
        dp[1] = 1;
 
        // Computing f(i) for each 2 <= i <= n.
        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]);
    }
     
    // driver code
    public static void main(String[] args)
    {
        int n = 4, k = 3, x = 2;
        System.out.println(countarray(n, k, x));
    }
}
 
 
// This code is contributed by rishabh_jain

Python3

# Python3 code to find count of arrays.
 
# Return the number of lists with 
# given constraints.
def countarray( n , k , x ):
     
    dp = list()
     
    # Initialising dp[0] and dp[1]
    dp.append(0)
    dp.append(1)
     
    # Computing f(i) for each 2 <= i <= n.
    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])
 
# Driven code
n = 4
k = 3
x = 2
print(countarray(n, k, x))
 
# This code is contributed by "Sharad_Bhardwaj".

C#

// C# program to find count of arrays.
using System;
 
class GFG
{
// static int MAXN = 109;
 
    public static int countarray(int n, int k, 
                                    int x)
    {
        int[] dp = new int[109];
 
        // Initialising dp[0] and dp[1].
        dp[0] = 0;
        dp[1] = 1;
 
        // Computing f(i) for each 2 <= i <= n.
        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]);
    }
     
    // Driver code
    public static void Main()
    {
        int n = 4, k = 3, x = 2;
        Console.WriteLine(countarray(n, k, x));
    }
}
 
 
// This code is contributed by vt_m

Javascript

<script>
 
// Javascript program to find count of arrays.
let MAXN = 109;
   
function countarray(n, k, x)
{
    let dp = [];
 
    // Initialising dp[0] and dp[1].
    dp[0] = 0;
    dp[1] = 1;
 
    // Computing f(i) for each 2 <= i <= n.
    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]);
}
 
// Driver code
let n = 4, k = 3, x = 2;
 
document.write(countarray(n, k, x));
 
// This code is contributed by sanjoy_62
 
</script>

PHP

<?php
// PHP Program to find 
// count of arrays.
 
$MAXN = 109;
 
// Return the number of arrays
// with given constraints.
function countarray($n, $k, $x)
{
    $dp = array( 0 );
 
    // Initialising dp[0] and dp[1].
    $dp[0] = 0;
    $dp[1] = 1;
 
    // Computing f(i) for 
    // each 2 <= i <= n.
    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]);
}
 
// Driven Code
$n = 4; $k = 3; $x = 2;
echo countarray($n, $k, $x) ;
 
// This code is contributed by anuj_67.
?>

Output

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++

// CPP Program to find count of arrays.
#include <bits/stdc++.h>
#define MAXN 109
using namespace std;
 
// Return the number of arrays with given constraints.
int countarray(int n, int k, int x)
{
    // initialize variables to store previous values
    int prev1 = 0, prev2 = 1, curr;
 
    // Computing f(i) for each 2 <= i <= n.
    for (int i = 2; i < n; i++) {
        curr = (k - 2) * prev2 + (k - 1) * prev1;
 
        // assigning values to iterate further
        prev1 = prev2;
        prev2 = curr;
    }
 
    // return final answer
    return (x == 1 ? (k - 1) * prev1 : prev2);
}
 
// Driven Program
int main()
{
    int n = 4, k = 3, x = 2;
 
    // function call
    cout << countarray(n, k, x) << endl;
    return 0;
}

Java

import java.util.*;
 
public class Main {
 
    // Return the number of arrays with given constants.
    static int countArray(int n, int k, int x)
    {
        // initialize variables to store previous values
        int prev1 = 0, prev2 = 1, curr;
        // Computing f(i) for each 2 <= i <= n.
        for (int i = 2; i < n; i++) {
            curr = (k - 2) * prev2 + (k - 1) * prev1;
            // assigning values to iterate further
            prev1 = prev2;
            prev2 = curr;
        }
        // return final answer
        return (x == 1 ? (k - 1) * prev1 : prev2);
    }
 
    // Driver Program
    public static void main(String[] args)
    {
        int n = 4, k = 3, x = 2;
        // function call
        System.out.println(countArray(n, k, x));
    }
}

Python3

def countarray(n, k, x):
    # initialize variables to store previous values
    prev1 = 0
    prev2 = 1
 
    # Computing f(i) for each 2 <= i <= n.
    for i in range(2, n):
        curr = (k - 2) * prev2 + (k - 1) * prev1
 
        # assigning values to iterate further
        prev1 = prev2
        prev2 = curr
 
    # return final answer
    return (k - 1) * prev1 if x == 1 else prev2
 
 
# Driven Program
n = 4
k = 3
x = 2
 
# function call
print(countarray(n, k, x))

C#

using System;
 
public class Program 
{
 
  // Return the number of arrays with given constartints.
  public static int CountArray(int n, int k, int x)
  {
    // initialize variables to store previous values
    int prev1 = 0, prev2 = 1, curr;
 
    // Computing f(i) for each 2 <= i <= n.
    for (int i = 2; i < n; i++) {
      curr = (k - 2) * prev2 + (k - 1) * prev1;
 
      // assigning values to iterate further
      prev1 = prev2;
      prev2 = curr;
    }
 
    // return final answer
    return (x == 1 ? (k - 1) * prev1 : prev2);
  }
 
  // Driven Program
  public static void Main()
  {
    int n = 4, k = 3, x = 2;
 
    // function call
    Console.WriteLine(CountArray(n, k, x));
  }
}

Javascript

// Function to calculate the number of arrays with given constants.
function countArray(n, k, x) {
    let prev1 = 0, prev2 = 1, curr;
 
    // Computing f(i) for each 2 <= i < n.
    for (let i = 2; i < n; i++) {
        // Calculate the current value using the given formula.
        curr = (k - 2) * prev2 + (k - 1) * prev1;
         
        // Update the previous values for the next iteration.
        prev1 = prev2;
        prev2 = curr;
    }
     
    // Return the final answer based on the value of x.
    return (x === 1 ? (k - 1) * prev1 : prev2);
}
 
// Input values
let n = 4, k = 3, x = 2;
 
// Calculate and output the result
console.log(countArray(n, k, x));