Build Array Where You Can Find The Maximum Exactly K Comparisons

Build Array Where You Can Find The Maximum Exactly K Comparisons - Problem

Build Array Where You Can Find The Maximum Exactly K Comparisons

Imagine you're designing a number guessing game! You need to construct an array of n integers where each element is between 1 and m. But here's the twist: when someone searches for the maximum element using a specific algorithm, they should make exactly k comparisons.

The search algorithm works like this:
• Start with search_cost = 0
• Go through each element from left to right
• If the current element is greater than all previous elements (a new maximum), increment search_cost

Your goal: Count how many different arrays satisfy this condition. Since the answer can be huge, return it modulo 10⁹ + 7.

Example: For array [2,3,1,3], the search_cost is 2 because:
• Position 0: 2 is new max → cost = 1
• Position 1: 3 > 2 (new max) → cost = 2
• Position 2: 1 ≤ 3 (no change)
• Position 3: 3 ≤ 3 (no change)

Input & Output

example_1.py — Python

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

› Output: 6

💡 Note: Arrays with exactly 1 search cost: [1,1], [2,1], [2,2], [3,1], [3,2], [3,3]. Each has only the first element as a new maximum.

example_2.py — Python

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

› Output: 0

💡 Note: Impossible to have 3 search costs with only values 1 and 2 in 5 positions. Maximum possible search cost is 2.

example_3.py — Python

$ Input: n = 9, m = 1, k = 1

› Output: 1

💡 Note: Only one possible array [1,1,1,1,1,1,1,1,1] with search cost 1 (first element creates the maximum).

Constraints

1 ≤ n ≤ 50
1 ≤ m ≤ 100
1 ≤ k ≤ n
Answer should be returned modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Start Building

Begin with empty trail, need to place n sections with heights 1 to m

Track State

Keep track of: position in trail, highest peak so far, peaks encountered

Make Decisions

At each position, decide whether to place a new peak or stay below current max

Use Memoization

Remember results for (position, max_height, peaks_seen) to avoid recalculation

Key Takeaway

🎯 Key Insight: We only need to track the current maximum height and peak count, not the entire trail built so far. This reduces the problem complexity significantly and makes memoization effective.

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 22

The optimal solution uses 3D Dynamic Programming with memoization. We track three states: current position, maximum value seen so far, and search cost. For each position, we try all possible values 1 to m, updating the maximum and search cost accordingly. The key insight is that we only need to know the current maximum (not the entire array built so far) to make decisions about future positions.

Common Approaches

Approach	Time	Space	Notes
✓ 3D Dynamic Programming (Optimal)	O(n × m × k × m)	O(n × m × k)	Use memoized recursion with states: position, current_max, search_cost

3D Dynamic Programming (Optimal) — Algorithm Steps

Define DP state: dp[position][max_so_far][search_cost]
Base case: dp[0][0][0] = 1 (empty array)
For each position, try placing values 1 to m
If value > current_max, increment search_cost
Use memoization to avoid recalculating subproblems

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start at dp(0,0,0) - position 0, no max yet, 0 cost

Try Values

For each position, try placing values 1 to m

Update State

If value > current_max, increment search_cost

Memoize

Store results to avoid recalculating same states

Code -

solution.c — C

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

const int MOD = 1000000007;

typedef struct {
    int pos, max, cost, result;
} MemoEntry;

MemoEntry memo[55][55][55];
int memo_initialized[55][55][55];

int dp(int pos, int currentMax, int searchCost, int n, int m, int k) {
    if (pos == n) {
        return searchCost == k ? 1 : 0;
    }
    
    if (searchCost > k) {
        return 0;
    }
    
    if (memo_initialized[pos][currentMax][searchCost]) {
        return memo[pos][currentMax][searchCost].result;
    }
    
    long long result = 0;
    
    for (int val = 1; val <= m; val++) {
        int newMax = currentMax;
        int newCost = searchCost;
        
        if (val > currentMax) {
            newMax = val;
            newCost++;
        }
        
        result = (result + dp(pos + 1, newMax, newCost, n, m, k)) % MOD;
    }
    
    memo[pos][currentMax][searchCost].result = result;
    memo_initialized[pos][currentMax][searchCost] = 1;
    return result;
}

int numOfArrays(int n, int m, int k) {
    memset(memo_initialized, 0, sizeof(memo_initialized));
    return dp(0, 0, 0, n, m, k);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n × m × k × m)

We have n×m×k states, and for each state we try m possible values

✓ Linear Growth

Space Complexity

O(n × m × k)

3D memoization table for all possible states

⚡ Linearithmic Space

68.0K Views

Medium Frequency

~25 min Avg. Time

1.7K 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

3D Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler