Maximum Frequency After Subarray Operation

Maximum Frequency After Subarray Operation - Problem

Array Hash Table Dynamic Programming Greedy Enumeration Prefix Sum Medium

You are given an array nums of length n. You are also given an integer k.

You perform the following operation on nums once:

Select a subarray nums[i..j] where 0 <= i <= j <= n - 1
Select an integer x and add x to all the elements in nums[i..j]

Find the maximum frequency of the value k after the operation.

Input & Output

Example 1 — Basic Transformation

$ Input: nums = [1,2,4,2], k = 4

› Output: 2

💡 Note: Select subarray [1,1] and add x=2. Array becomes [1,4,4,2]. The frequency of 4 is 2.

Example 2 — No Transformation Needed

$ Input: nums = [1,4,4,2,4], k = 4

› Output: 4

💡 Note: Select subarray [3,3] and add x=2. Array becomes [1,4,4,4,4]. The frequency of 4 is 4.

Example 3 — Single Element

$ Input: nums = [5], k = 3

› Output: 1

💡 Note: Select subarray [0,0] and add x=-2. Array becomes [3]. The frequency of 3 is 1.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i], k ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 12 M Microsoft 8 a Amazon 15

The key insight is that we can transform any subarray by adding the same value to all elements. We need to find the transformation that maximizes the frequency of target k. The optimal approach systematically tries all meaningful transformations on all possible subarrays. Time: O(n³), Space: O(n)

Common Approaches

✓ Brute Force - Try All Subarrays

⏱️ Time: O(n³) Space: O(1)

For each possible subarray [i,j], calculate what value x we need to add to make elements equal to k, then count total frequency of k in the resulting array.

Frequency Count Optimization

⏱️ Time: O(n²) Space: O(n)

Instead of trying all subarrays, group elements by the value they need to be transformed to k. For elements with the same transformation value, we can count how many contribute to k.

Optimized Enumeration

⏱️ Time: O(n³) Space: O(n)

Instead of trying every subarray, we recognize that for any subarray [i,j], all elements get the same transformation x. We only need to try transformations that make at least one element equal to k.

Brute Force - Try All Subarrays — Algorithm Steps

Iterate through all possible subarrays [i,j]
For each subarray, calculate x = k - nums[i] to transform elements
Count frequency of k after transformation
Track maximum frequency

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Subarray [0,0]

Transform first element to target k

Try Subarray [0,1]

Transform first two elements

Count Frequency

Count occurrences of k after each transformation

Code -

solution.c — C

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

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int max(int a, int b) {
    return a > b ? a : b;
}

int solution(int* arr1, int* arr2, int n) {
    int maxVal = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            int val = abs_val(arr1[i] - arr1[j]) + abs_val(arr2[i] - arr2[j]) + abs_val(i - j);
            maxVal = max(maxVal, val);
        }
    }
    
    return maxVal;
}

int parseArray(char* line, int* arr) {
    int n = 0;
    char* ptr = line;
    
    // Skip to first '['
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    while (*ptr && *ptr != ']') {
        // Skip whitespace and commas
        while (*ptr && (*ptr == ' ' || *ptr == ',' || *ptr == '\n' || *ptr == '\t')) ptr++;
        
        if (*ptr && *ptr != ']') {
            arr[n++] = atoi(ptr);
            // Move to next number (skip current number)
            if (*ptr == '-') ptr++;
            while (*ptr && *ptr >= '0' && *ptr <= '9') ptr++;
        }
    }
    
    return n;
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int arr1[100], arr2[100];
    int n1 = parseArray(line1, arr1);
    int n2 = parseArray(line2, arr2);
    
    printf("%d\n", solution(arr1, arr2, n1));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for all subarrays × O(n) to count frequency for each

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables

⚡ Linearithmic Space

8.5K Views

Medium Frequency

~35 min Avg. Time

180 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 - Try All Subarrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler