# Count of distinct N-size Arrays with elements upto K such that adjacent element pair is either ascending or non-multiples

Given two integers **N** and **K**, find the distinct number of ways to create an array of **N** elements where each element is in the range **[1, K]** and every pair of adjacent elements (P, Q) is such that either **P <= Q** or **P % Q > 0**.

**Example:**

Input:N = 2, K = 3Output:7Explantation:The arrays that satisfies the given conditions are {1, 1}, {1, 2}, {1, 3}, {2, 2}, {2, 3}, {3, 3}, {3, 2}.

Input:N = 9, K = 1Output:1Explaination:: The only arrays that satisfies the given conditions is {1, 1, 1, 1, 1, 1, 1, 1, 1}.

**Approach:** The given problem can be solved using Dynamic Programming based on the following observations:

- Consider a 2D array, say
**dp[][]**where**dp[x][y]**represents the count of arrays of length**x**having**y**as their last element. - Now, the number of ways to create an array of length
**x**having**y**as their last element and having all array elements in the range**[1, K]**is the sum of ways to create an array of length**(y – 1)**having the last element over the range**[1, K]**and can be represented as relation . - The only cases where
**P <= Q**or**P % Q > 0**are to be considered where (P, Q) are the pair of adjacent elements. The array that do not satisfy either of these conditions can be subtracted from each state using the relation are where**y % j = 0**.

From the above observations, compute the dp[][] table and print the value of **dp[N][K]** as the resultant count of arrays formed. Follow the steps below to solve the given problem:

- Store all the divisors of all the integers over the range
**[1, K]**using the approach in Sieve of Eratosthenes in an array say**divisor[][]**. - Initialize a 2D array, say
**dp[][]**of dimension**(N + 1)*(K + 1)**such that**dp[x][y]**represents the count of arrays of length**x**having**y**as their last element. - Initialize a
**dp[1][j]**to**1**as the number of ways to create an array of size**1**having any element**j**as their last element is**1**. - Iterate over the range
**[2, N]**using the variable**x**and perform the following steps:- For each possible values of
**j**over the range**[1, K]**increment the value of**dp[x][y]**by**dp[x – 1][j]**. - Iterate over the range
**[1, K]**using the value of**y**and for each divisor,**say D**of**y**decrement the value of**dp[x][y]**by**dp[x – 1][D]**as this doesn’t satisfy cases where**P <= Q**or**P % Q > 0**for all pair of adjacent elements**(P, Q)**.

- For each possible values of
- After completing the above steps, print the value of as the result.

Below is the implementation of the above approach:

## C++

`// C++ program of the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to find the count of distinct` `// arrays of size n having elements in` `// range [1, k] and all adjacent elements` `// (P, Q) follows (P <= Q) or (P % Q > 0)` `int` `countArrays(` `int` `n, ` `int` `k)` `{` ` ` `// Stores the divisors of all` ` ` `// integers in the range [1, k]` ` ` `vector<vector<` `int` `> > divisors(k + 1);` ` ` `// Calculate the divisors of all` ` ` `// integers using the Sieve` ` ` `for` `(` `int` `i = 1; i <= k; i++) {` ` ` `for` `(` `int` `j = 2 * i; j <= k; j += i) {` ` ` `divisors[j].push_back(i);` ` ` `}` ` ` `}` ` ` `// Stores the dp states such that` ` ` `// dp[i][j] with i elements having` ` ` `// j as the last element of array` ` ` `vector<vector<` `int` `> > dp(` ` ` `n + 1, vector<` `int` `>(k + 1));` ` ` `// Initialize the dp array` ` ` `for` `(` `int` `j = 1; j <= k; j++) {` ` ` `dp[1][j] = 1;` ` ` `}` ` ` `// Calculate the dp states using the` ` ` `// derived relation` ` ` `for` `(` `int` `x = 2; x <= n; x++) {` ` ` `// Calculate the sum for len-1` ` ` `int` `sum = 0;` ` ` `for` `(` `int` `j = 1; j <= k; j++) {` ` ` `sum += dp[x - 1][j];` ` ` `}` ` ` `// Subtract dp[len-1][j] for each` ` ` `// factor of j from [1, K]` ` ` `for` `(` `int` `y = 1; y <= k; y++) {` ` ` `dp[x][y] = sum;` ` ` `for` `(` `int` `d : divisors[y]) {` ` ` `dp[x][y] = (dp[x][y] - dp[x - 1][d]);` ` ` `}` ` ` `}` ` ` `}` ` ` `// Calculate the final result` ` ` `int` `sum = 0;` ` ` `for` `(` `int` `j = 1; j <= k; j++) {` ` ` `sum += dp[n][j];` ` ` `}` ` ` `// Return the resultant sum` ` ` `return` `sum;` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `N = 2, K = 3;` ` ` `cout << countArrays(N, K);` ` ` `return` `0;` `}` |

## Java

`// Java program of the above approach` `import` `java.util.*;` `class` `GFG{` `// Function to find the count of distinct` `// arrays of size n having elements in` `// range [1, k] and all adjacent elements` `// (P, Q) follows (P <= Q) or (P % Q > 0)` `static` `int` `countArrays(` `int` `n, ` `int` `k)` `{` ` ` `// Stores the divisors of all` ` ` `// integers in the range [1, k]` ` ` `Vector<Integer> []divisors = ` `new` `Vector[k + ` `1` `];` ` ` `for` `(` `int` `i = ` `0` `; i < divisors.length; i++)` ` ` `divisors[i] = ` `new` `Vector<Integer>();` ` ` `// Calculate the divisors of all` ` ` `// integers using the Sieve` ` ` `for` `(` `int` `i = ` `1` `; i <= k; i++) {` ` ` `for` `(` `int` `j = ` `2` `* i; j <= k; j += i) {` ` ` `divisors[j].add(i);` ` ` `}` ` ` `}` ` ` `// Stores the dp states such that` ` ` `// dp[i][j] with i elements having` ` ` `// j as the last element of array` ` ` `int` `[][] dp = ` `new` `int` `[n + ` `1` `][k + ` `1` `];` ` ` `// Initialize the dp array` ` ` `for` `(` `int` `j = ` `1` `; j <= k; j++) {` ` ` `dp[` `1` `][j] = ` `1` `;` ` ` `}` ` ` `// Calculate the dp states using the` ` ` `// derived relation` ` ` `for` `(` `int` `x = ` `2` `; x <= n; x++) {` ` ` `// Calculate the sum for len-1` ` ` `int` `sum = ` `0` `;` ` ` `for` `(` `int` `j = ` `1` `; j <= k; j++) {` ` ` `sum += dp[x - ` `1` `][j];` ` ` `}` ` ` `// Subtract dp[len-1][j] for each` ` ` `// factor of j from [1, K]` ` ` `for` `(` `int` `y = ` `1` `; y <= k; y++) {` ` ` `dp[x][y] = sum;` ` ` `for` `(` `int` `d : divisors[y]) {` ` ` `dp[x][y] = (dp[x][y] - dp[x - ` `1` `][d]);` ` ` `}` ` ` `}` ` ` `}` ` ` `// Calculate the final result` ` ` `int` `sum = ` `0` `;` ` ` `for` `(` `int` `j = ` `1` `; j <= k; j++) {` ` ` `sum += dp[n][j];` ` ` `}` ` ` `// Return the resultant sum` ` ` `return` `sum;` `}` `// Driver Code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `N = ` `2` `, K = ` `3` `;` ` ` `System.out.print(countArrays(N, K));` `}` `}` `// This code is contributed by 29AjayKumar` |

## Python3

`# Python 3 program of the above approach` `# Function to find the count of distinct` `# arrays of size n having elements in` `# range [1, k] and all adjacent elements` `# (P, Q) follows (P <= Q) or (P % Q > 0)` `def` `countArrays(n, k):` ` ` ` ` `# Stores the divisors of all` ` ` `# integers in the range [1, k]` ` ` `divisors ` `=` `[[] ` `for` `i ` `in` `range` `(k ` `+` `1` `)]` ` ` `# Calculate the divisors of all` ` ` `# integers using the Sieve` ` ` `for` `i ` `in` `range` `(` `1` `, k ` `+` `1` `, ` `1` `):` ` ` `for` `j ` `in` `range` `(` `2` `*` `i, k ` `+` `1` `, i):` ` ` `divisors[j].append(i)` ` ` `# Stores the dp states such that` ` ` `# dp[i][j] with i elements having` ` ` `# j as the last element of array` ` ` `dp ` `=` `[[` `0` `for` `i ` `in` `range` `(k` `+` `1` `)] ` `for` `j ` `in` `range` `(n ` `+` `1` `)]` ` ` `# Initialize the dp array` ` ` `for` `j ` `in` `range` `(` `1` `, k ` `+` `1` `, ` `1` `):` ` ` `dp[` `1` `][j] ` `=` `1` ` ` `# Calculate the dp states using the` ` ` `# derived relation` ` ` `for` `x ` `in` `range` `(` `2` `, n ` `+` `1` `, ` `1` `):` ` ` `# Calculate the sum for len-1` ` ` `sum` `=` `0` ` ` `for` `j ` `in` `range` `(` `1` `, k ` `+` `1` `, ` `1` `):` ` ` `sum` `+` `=` `dp[x ` `-` `1` `][j]` ` ` `# Subtract dp[len-1][j] for each` ` ` `# factor of j from [1, K]` ` ` `for` `y ` `in` `range` `(` `1` `, k ` `+` `1` `, ` `1` `):` ` ` `dp[x][y] ` `=` `sum` ` ` `for` `d ` `in` `divisors[y]:` ` ` `dp[x][y] ` `=` `(dp[x][y] ` `-` `dp[x ` `-` `1` `][d])` ` ` `# Calculate the final result` ` ` `sum` `=` `0` ` ` `for` `j ` `in` `range` `(` `1` `, k ` `+` `1` `, ` `1` `):` ` ` `sum` `+` `=` `dp[n][j]` ` ` `# Return the resultant sum` ` ` `return` `sum` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` `N ` `=` `2` ` ` `K ` `=` `3` ` ` `print` `(countArrays(N, K))` ` ` ` ` `# This code is contributed by ipg2016107.` |

## C#

`// C# program for the approach` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG {` `// Function to find the count of distinct` `// arrays of size n having elements in` `// range [1, k] and all adjacent elements` `// (P, Q) follows (P <= Q) or (P % Q > 0)` `static` `int` `countArrays(` `int` `n, ` `int` `k)` `{` ` ` `// Stores the divisors of all` ` ` `// integers in the range [1, k]` ` ` `List<` `int` `> []divisors = ` `new` `List<` `int` `>[k + 1];` ` ` `for` `(` `int` `i = 0; i < divisors.Length; i++)` ` ` `divisors[i] = ` `new` `List<` `int` `>();` ` ` `// Calculate the divisors of all` ` ` `// integers using the Sieve` ` ` `for` `(` `int` `i = 1; i <= k; i++) {` ` ` `for` `(` `int` `j = 2 * i; j <= k; j += i) {` ` ` `divisors[j].Add(i);` ` ` `}` ` ` `}` ` ` `// Stores the dp states such that` ` ` `// dp[i][j] with i elements having` ` ` `// j as the last element of array` ` ` `int` `[,] dp = ` `new` `int` `[n + 1, k + 1];` ` ` `// Initialize the dp array` ` ` `for` `(` `int` `j = 1; j <= k; j++) {` ` ` `dp[1, j] = 1;` ` ` `}` ` ` ` ` `int` `sum;` ` ` `// Calculate the dp states using the` ` ` `// derived relation` ` ` `for` `(` `int` `x = 2; x <= n; x++) {` ` ` `// Calculate the sum for len-1` ` ` `sum = 0;` ` ` `for` `(` `int` `j = 1; j <= k; j++) {` ` ` `sum += dp[x - 1, j];` ` ` `}` ` ` `// Subtract dp[len-1][j] for each` ` ` `// factor of j from [1, K]` ` ` `for` `(` `int` `y = 1; y <= k; y++) {` ` ` `dp[x, y] = sum;` ` ` `foreach` `(` `int` `d ` `in` `divisors[y]) {` ` ` `dp[x, y] = (dp[x, y] - dp[x - 1, d]);` ` ` `}` ` ` `}` ` ` `}` ` ` `// Calculate the final result` ` ` `sum = 0;` ` ` `for` `(` `int` `j = 1; j <= k; j++) {` ` ` `sum += dp[n, j];` ` ` `}` ` ` `// Return the resultant sum` ` ` `return` `sum;` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `Main()` ` ` `{` ` ` `int` `N = 2, K = 3;` ` ` `Console.Write(countArrays(N, K));` ` ` `}` `}` `// This code is contributed by sanjoy_62.` |

## Javascript

`<script>` ` ` `// JavaScript Program to implement` ` ` `// the above approach` ` ` `// Function to find the count of distinct` ` ` `// arrays of size n having elements in` ` ` `// range [1, k] and all adjacent elements` ` ` `// (P, Q) follows (P <= Q) or (P % Q > 0)` ` ` `function` `countArrays(n, k)` ` ` `{` ` ` ` ` `// Stores the divisors of all` ` ` `// integers in the range [1, k]` ` ` `let divisors = ` `new` `Array(k + 1).fill(` `new` `Array());` ` ` `// Calculate the divisors of all` ` ` `// integers using the Sieve` ` ` `for` `(let i = 1; i <= k; i++) {` ` ` `for` `(let j = 2 * i; j <= k; j += i) {` ` ` `divisors[j].push(i);` ` ` `}` ` ` `}` ` ` `// Stores the dp states such that` ` ` `// dp[i][j] with i elements having` ` ` `// j as the last element of array` ` ` `let dp = ` `new` `Array(n + 1).fill(` `new` `Array(k + 1));` ` ` `// Initialize the dp array` ` ` `for` `(let j = 1; j <= k; j++) {` ` ` `dp[1][j] = 1;` ` ` `}` ` ` `// Calculate the dp states using the` ` ` `// derived relation` ` ` `for` `(let x = 2; x <= n; x++) {` ` ` `// Calculate the sum for len-1` ` ` `let sum = 0;` ` ` `for` `(let j = 1; j <= k; j++) {` ` ` `sum += dp[x - 1][j];` ` ` `}` ` ` `// Subtract dp[len-1][j] for each` ` ` `// factor of j from [1, K]` ` ` `for` `(let y = 1; y <= k; y++) {` ` ` `dp[x][y] = sum;` ` ` `for` `(let d of divisors[y]) {` ` ` `dp[x][y] = (dp[x][y] - dp[x - 1][d]);` ` ` `}` ` ` `}` ` ` `}` ` ` `// Calculate the final result` ` ` `let sum = 0;` ` ` `for` `(let j = 1; j <= k; j++) {` ` ` `sum += dp[n][j];` ` ` `}` ` ` `sum++;` ` ` ` ` `// Return the resultant sum` ` ` `return` `sum;` ` ` `}` ` ` `// Driver Code` ` ` `let N = 2, K = 3;` ` ` `document.write(countArrays(N, K));` `// This code is contributed by Potta Lokesh` ` ` `</script>` |

**Output**

7

**Time Complexity: **O(N*K*log K) **Auxiliary Space: **O(K*log K)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.