Find the Number of K-Even Arrays - Practice Coding Problems

Find the Number of K-Even Arrays - Problem

Dynamic Programming Medium

You're tasked with counting special arrays based on a unique mathematical property! Given three integers n (array size), m (maximum value), and k (target count), you need to find how many arrays of size n have exactly k "magic pairs".

A magic pair occurs at index i when the expression (arr[i] * arr[i+1]) - arr[i] - arr[i+1] evaluates to an even number. All array elements must be in the range [1, m].

Goal: Count all possible k-even arrays and return the result modulo 10^9 + 7.

Example: For array [2, 3, 1], check pairs: (2*3) - 2 - 3 = 1 (odd), (3*1) - 3 - 1 = -1 (odd). This array has 0 magic pairs.

Input & Output

example_1.py — Basic Case

$ Input: n = 3, m = 2, k = 1

› Output: 4

💡 Note: Arrays with exactly 1 magic pair: [1,1,2], [2,2,1], [1,2,2], [2,1,1]. Magic pairs occur when both numbers have same parity (both odd or both even).

example_2.py — No Magic Pairs

$ Input: n = 2, m = 3, k = 0

› Output: 6

💡 Note: Arrays with 0 magic pairs: [1,2], [1,3], [2,1], [2,3], [3,1], [3,2]. All pairs have different parity (one odd, one even).

example_3.py — Edge Case

$ Input: n = 1, m = 5, k = 0

› Output: 5

💡 Note: Single element arrays have no adjacent pairs, so k must be 0. All 5 possible arrays [1], [2], [3], [4], [5] are valid.

Constraints

1 ≤ n ≤ 1000
1 ≤ m ≤ 1000
0 ≤ k ≤ n-1
Answer must be returned modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

State Definition

dp[position][last_parity][magic_count] = number of ways

Transition Logic

For each new number, check if it creates a magic pair with previous

Parity Check

Magic pair formed when both numbers odd or both even

Final Count

Sum all states with exactly k magic pairs

Key Takeaway

🎯 Key Insight: Use DP to track position, last element's parity, and magic pair count. Magic pairs form when adjacent elements have same parity, making this a manageable state space of O(n*2*k).

Asked in

G Google 25 f Meta 18 a Amazon 15 ⊞ Microsoft 12

The optimal solution uses dynamic programming with state tracking. Key insight: (a*b) - a - b is even when both numbers have the same parity (both odd or both even). We track dp[pos][parity][count] representing ways to fill positions with last element having given parity and magic pair count.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Arrays)	O(m^n * n)	O(n)	Generate every possible array and count magic pairs for each

Brute Force (Generate All Arrays) — Algorithm Steps

Generate all possible arrays of size n with values [1, m]
For each array, iterate through adjacent pairs
Calculate (arr[i] * arr[i+1]) - arr[i] - arr[i+1] for each pair
Count arrays where exactly k pairs produce even results
Return count modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Arrays

Create all possible arrays of size n with values 1 to m

Check Pairs

For each array, examine all adjacent pairs

Count Magic

Count pairs where (a*b) - a - b is even

Filter Results

Keep only arrays with exactly k magic pairs

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

#define MOD 1000000007

int count_result = 0;

void generateArrays(int* arr, int pos, int n, int m, int k) {
    if (pos == n) {
        int magicPairs = 0;
        for (int i = 0; i < n - 1; i++) {
            if (((arr[i] * arr[i + 1]) - arr[i] - arr[i + 1]) % 2 == 0) {
                magicPairs++;
            }
        }
        if (magicPairs == k) {
            count_result = (count_result + 1) % MOD;
        }
        return;
    }
    
    for (int val = 1; val <= m; val++) {
        arr[pos] = val;
        generateArrays(arr, pos + 1, n, m, k);
    }
}

int countKEvenArrays(int n, int m, int k) {
    count_result = 0;
    int* arr = (int*)malloc(n * sizeof(int));
    generateArrays(arr, 0, n, m, k);
    free(arr);
    return count_result;
}

int main() {
    int n, m, k;
    scanf("%d %d %d", &n, &m, &k);
    printf("%d\n", countKEvenArrays(n, m, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m^n * n)

Generate m^n arrays, check n-1 pairs for each array

✓ Linear Growth

Space Complexity

O(n)

Space for current array being generated

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Generate All Arrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler