Maximize the Beauty of the Garden - Practice Coding Problems

Maximize the Beauty of the Garden - Problem

Imagine you're a master gardener tasked with creating the most beautiful garden possible! 🌸

You have a garden of n flowers arranged in a line, where each flower has an integer beauty value. Your goal is to create a valid garden by potentially removing some flowers, then calculate the maximum possible total beauty.

What makes a garden valid?

It must have at least 2 flowers
The first and last flowers must have the same beauty value

You're given an array flowers where flowers[i] represents the beauty of the i-th flower. You can remove any flowers you want (or none at all) to maximize the beauty sum of the remaining valid garden.

Example: If you have flowers [1, 2, 3, 1, 5], you could keep the subsequence [1, 2, 3, 1] (beauty sum = 7) or [1, 5, 1] by rearranging... wait, no rearranging allowed! You must maintain the original order.

Input & Output

example_1.py — Basic Valid Garden

$ Input: [1, 2, 3, 1, 5]

› Output: 7

💡 Note: We can create a valid garden with flowers [1, 2, 3, 1] by keeping indices 0-3. The first and last flowers both have value 1, and the total beauty is 1 + 2 + 3 + 1 = 7. We could also choose just [1, 1] for beauty 2, but 7 is optimal.

example_2.py — Multiple Valid Gardens

$ Input: [2, -3, 4, -1, 2, 6]

› Output: 4

💡 Note: The optimal valid garden is [2, -3, 4, -1, 2] using indices 0-4. First and last flowers both have value 2, and total beauty is 2 + (-3) + 4 + (-1) + 2 = 4. Other valid options like just [2, 2] would give beauty = 4, but removing the middle elements doesn't help here.

example_3.py — No Valid Garden

$ Input: [1, 2, 3, 4, 5]

› Output: 0

💡 Note: No two flowers have the same beauty value, so we cannot create a valid garden where the first and last flowers match. Return 0.

Constraints

2 ≤ flowers.length ≤ 10⁵
-10⁴ ≤ flowers[i] ≤ 10⁴
The garden must have at least 2 flowers
First and last flowers must have the same beauty value

Visualization

Tap to expand

Understanding the Visualization

Identify Matching Pairs

Find flowers with the same beauty value that could serve as garden boundaries

Calculate Garden Beauty

For each valid pair, sum all flowers between them (inclusive)

Optimize with Hash Table

Use hash map to remember first occurrence and avoid recalculation

One-Pass Solution

Combine hash lookup with running sum for maximum efficiency

Key Takeaway

🎯 Key Insight: By combining hash table lookup with running prefix sums in a single pass, we can instantly calculate the beauty of any valid garden formed by matching flower pairs, achieving optimal O(n) time complexity.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses a one-pass hash table approach with running prefix sums. We track the first occurrence of each flower value while maintaining a running sum. When we encounter a flower value we've seen before, we can instantly calculate the garden beauty using the stored information. This achieves O(n) time and O(n) space complexity, making it perfect for interview settings.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass with Prefix Sums	O(n)	O(n)	Build prefix sums first, then use hash table to find matching flowers efficiently
One-Pass Hash Table (Optimal)	O(n)	O(n)	Track first occurrence and running sum simultaneously for maximum efficiency
Brute Force (Nested Loops)	O(n³)	O(1)	Try all possible pairs of matching flowers and compute sums between them

Two-Pass with Prefix Sums — Algorithm Steps

Build prefix sum array for O(1) range sum calculation
Iterate through flowers and use hash map to track first occurrence of each value
When we see a flower value again, calculate sum using prefix sums
Update maximum beauty found so far

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Prefix Sums

Precompute cumulative sums for instant range queries

Track First Occurrence

Store the first index where each flower value appears

Find Matching Pairs

When we see a value again, we have a valid garden

Calculate Sum in O(1)

Use prefix[j+1] - prefix[i] for sum from i to j

Code -

solution.c — C

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

#define MAX_VAL 100000
#define OFFSET 50000

int maximumBeauty(int* flowers, int n) {
    if (n < 2) return 0;
    
    // Build prefix sums for O(1) range queries
    long long* prefix = (long long*)calloc(n + 1, sizeof(long long));
    for (int i = 0; i < n; i++) {
        prefix[i + 1] = prefix[i] + flowers[i];
    }
    
    // Array to store first occurrence of each flower value
    int* firstOccurrence = (int*)malloc((MAX_VAL + 1) * sizeof(int));
    memset(firstOccurrence, -1, (MAX_VAL + 1) * sizeof(int));
    
    long long maxBeauty = 0;
    
    for (int i = 0; i < n; i++) {
        int flowerVal = flowers[i] + OFFSET; // Offset for negative values
        
        if (firstOccurrence[flowerVal] != -1) {
            // Found matching pair, calculate sum using prefix sums
            int startIdx = firstOccurrence[flowerVal];
            long long currentSum = prefix[i + 1] - prefix[startIdx];
            if (currentSum > maxBeauty) {
                maxBeauty = currentSum;
            }
        } else {
            // First time seeing this flower value
            firstOccurrence[flowerVal] = i;
        }
    }
    
    free(prefix);
    free(firstOccurrence);
    return (int) maxBeauty;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int flowers[1000];
    int n = 0;
    
    char* token = strtok(line, "[,]\n");
    while (token != NULL) {
        flowers[n++] = atoi(token);
        token = strtok(NULL, "[,]\n");
    }
    
    printf("%d\n", maximumBeauty(flowers, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) to build prefix sums + O(n) to iterate and check hash map

✓ Linear Growth

Space Complexity

O(n)

O(n) for prefix sum array + O(n) for hash map in worst case

⚡ Linearithmic Space

58.0K Views

High Frequency

~18 min Avg. Time

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

Two-Pass with Prefix Sums — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler