Build Array Where You Can Find The Maximum Exactly K Comparisons

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

You are given three integers n, m, and k. You need to build an array arr of exactly n integers where each integer is between 1 and m (inclusive).

Consider an algorithm that finds the maximum element by scanning the array from left to right. The algorithm counts how many times it finds a new maximum (including the first element). This count is called the search cost.

Your task is to count how many different arrays have a search cost of exactly k. Since the answer can be very large, return it modulo 10^9 + 7.

Example: For array [3, 1, 4, 2], the search cost is 2 because we find new maximums at positions 0 (value 3) and 2 (value 4).

Input & Output

Example 1 — Basic Case

$ 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 — Multiple Peaks

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

› Output: 6

💡 Note: Arrays: [1,2,1], [1,2,2], [2,1,2] have cost 2. We need exactly 2 new maximums found during the scan.

Example 3 — Edge Case

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

› Output: 1

💡 Note: Only one array possible: [1]. It has exactly 1 search cost (the first element).

Constraints

1 ≤ n ≤ 50
1 ≤ m ≤ 100
1 ≤ k ≤ n

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 8

The key insight is to use dynamic programming with states tracking position, current maximum, and remaining peaks. The optimal approach uses 3D DP to count arrays efficiently. Time: O(n × m × k), Space: O(n × m × k).

Common Approaches

✓ 2D Dynamic Programming

⏱️ Time: O(n × m × k) Space: O(n × k)

Create a DP table where dp[i][j] represents the number of ways to build an array of length i with exactly j search cost. Build the solution iteratively by considering all possible values at each position.

Brute Force Recursion

⏱️ Time: O(m^n × n) Space: O(n)

Try every possible value at each position and recursively build all arrays. For each complete array, simulate the search algorithm to count the search cost.

Memoized Recursion

⏱️ Time: O(n × m × k) Space: O(n × m × k)

Define recursive states as (position, current_max, remaining_peaks). Use memoization to cache results and avoid exponential time complexity.

2D Dynamic Programming — Algorithm Steps

Initialize DP table: dp[length][cost] = ways
For each position, consider placing each value 1 to m
Update DP based on whether new value creates a peak
Return dp[n][k]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set up 3D DP table for [length][cost][max_value]

Fill

Iterate through positions, updating table based on value choices

Sum

Sum all ways to achieve length n with exactly k peaks

Code -

solution.c — C

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

const int MOD = 1000000007;

int solution(int n, int m, int k) {
    // dp[i][j][maxVal] = ways to build array of length i with j peaks and maxVal as maximum
    long long dp[51][51][51]; // Assuming constraints
    memset(dp, 0, sizeof(dp));
    
    // Base case: empty array
    dp[0][0][0] = 1;
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j <= k; j++) {
            for (int maxVal = 0; maxVal <= m; maxVal++) {
                if (dp[i][j][maxVal] == 0) continue;
                
                // Place values from 1 to maxVal (no new peak)
                if (maxVal > 0) {
                    dp[i + 1][j][maxVal] = (dp[i + 1][j][maxVal] + 
                                          (long long) maxVal * dp[i][j][maxVal]) % MOD;
                }
                
                // Place values greater than maxVal (new peak)
                if (j < k) {
                    for (int val = maxVal + 1; val <= m; val++) {
                        dp[i + 1][j + 1][val] = (dp[i + 1][j + 1][val] + 
                                               dp[i][j][maxVal]) % MOD;
                    }
                }
            }
        }
    }
    
    long long result = 0;
    for (int maxVal = 1; maxVal <= m; maxVal++) {
        result = (result + dp[n][k][maxVal]) % MOD;
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n × m × k)

Three nested loops: n positions, m possible values, k cost levels

✓ Linear Growth

Space Complexity

O(n × k)

2D DP table stores ways for each length and cost combination

⚡ Linearithmic Space

23.0K Views

Medium Frequency

~35 min Avg. Time

892 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

2D Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler