Count the Number of Arrays with K Matching Adjacent Elements

Count the Number of Arrays with K Matching Adjacent Elements - Problem

Math Combinatorics Hard

You're tasked with counting the number of good arrays of size n where each element is in the range [1, m] and exactly k adjacent pairs have matching values.

What makes an array "good"?

The array has exactly n elements
Each element arr[i] is between 1 and m (inclusive)
There are exactly k indices where arr[i-1] == arr[i] (matching adjacent elements)

Goal: Return the count of all possible good arrays, modulo 10^9 + 7.

Example: For n=3, m=2, k=1, arrays like [1,1,2] and [2,2,1] are good because they have exactly 1 matching adjacent pair.

Input & Output

example_1.py — Basic Case

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

› Output: 6

💡 Note: With n=3 positions, m=2 colors, and k=1 match needed: Arrays like [1,1,2], [1,2,2], [2,1,1], [2,2,1], [1,2,1] with different arrangements give us 6 valid arrays total.

example_2.py — No Matches

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

› Output: 2

💡 Note: Arrays must have no adjacent matches: [1,2] and [2,1] are the only valid arrays.

example_3.py — All Matches

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

› Output: 2

💡 Note: Need exactly 2 adjacent matches (all elements same): [1,1,1] and [2,2,2] are the only valid arrays.

Constraints

1 ≤ n ≤ 1000
1 ≤ m ≤ 1000
0 ≤ k ≤ n-1
Answer fits in 32-bit integer after taking modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Choose First Plank

Start with any of the m colors - this gives us m starting possibilities

Build Incrementally

At each step, decide: match previous color (if we haven't used all k matches) or pick a different color

Track State

Keep track of: current position, matches used so far, and whether we can continue a matching sequence

Use Memoization

Cache results for identical subproblems to avoid redundant calculations

Key Takeaway

🎯 Key Insight: Use DP to build arrays incrementally, making optimal choices at each step while tracking matches used

Asked in

G Google 15 a Amazon 8 f Meta 6 ⊞ Microsoft 4

The optimal solution uses Dynamic Programming with memoization to efficiently count valid arrays. Key insight: at each position, we can either match the previous element (using one of our k matches) or choose a different value (m-1 options). The DP state tracks position, matches used, and whether we can extend a matching sequence, achieving O(n×k) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Arrays)	O(m^n * n)	O(n)	Generate all possible arrays and count those with exactly k matching pairs
Dynamic Programming (Optimal)	O(n × k)	O(n × k)	Use DP to track states: position, matches used, and whether last element matches previous

Brute Force (Generate All Arrays) — Algorithm Steps

Generate all possible arrays of length n with elements [1,m]
For each array, count adjacent matching pairs
Count arrays with exactly k matches
Return count modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Arrays

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

Count Matches

For each array, count adjacent matching pairs

Filter Results

Keep only arrays with exactly k matches

Code -

solution.c — C

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

#define MOD 1000000007

int generateArrays(int pos, int* arr, int matches, int n, int m, int k) {
    if (pos == n) {
        return matches == k ? 1 : 0;
    }
    
    int count = 0;
    for (int val = 1; val <= m; val++) {
        int newMatches = matches;
        if (pos > 0 && arr[pos-1] == val) {
            newMatches++;
        }
        if (newMatches <= k) {
            arr[pos] = val;
            count = (count + generateArrays(pos + 1, arr, newMatches, n, m, k)) % MOD;
        }
    }
    return count;
}

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

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

Time & Space Complexity

Time Complexity

⏱️

O(m^n * n)

m^n arrays to generate, each taking O(n) time to check matches

✓ Linear Growth

Space Complexity

O(n)

Space for current array being checked

⚡ 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