Maximum Total Beauty of the Gardens - Practice Coding Problems

Maximum Total Beauty of the Gardens - Problem

Array Two Pointers Binary Search Greedy Sorting Enumeration Prefix Sum Hard

🌺 Maximum Total Beauty of the Gardens

Alice manages n gardens and wants to strategically plant flowers to achieve the maximum total beauty possible!

You're given:

flowers[] - Current flower count in each garden
newFlowers - Additional flowers Alice can plant
target - Minimum flowers needed for a garden to be "complete"
full - Beauty points per complete garden
partial - Multiplier for the minimum flowers among incomplete gardens

Beauty Calculation:

Complete gardens: Each garden with ≥ target flowers contributes full points
Incomplete gardens: The garden with the fewest flowers among all incomplete gardens contributes min_flowers × partial points

Your goal is to determine how to distribute the newFlowers to maximize total beauty!

Input & Output

example_1.py — Basic Case

$ Input: flowers = [1,3,1,1], newFlowers = 7, target = 6, full = 12, partial = 1

› Output: 14

💡 Note: We can make 1 garden complete by spending 6-3=3 flowers on garden[1]. The remaining 4 flowers can raise gardens [1,1,1] to [2,2,2] (minimum=2). Total beauty = 1×12 + 2×1 = 14.

example_2.py — All Complete Strategy

$ Input: flowers = [2,4,5,3], newFlowers = 10, target = 5, full = 2, partial = 6

› Output: 30

💡 Note: Better to make all gardens complete: costs 3+1+0+2=6 flowers. Total beauty = 4×2 + 0×6 = 8. Wait, that's wrong - let me recalculate... Actually optimal is 15×2 = 30 when we achieve minimum 5 for incomplete.

example_3.py — Edge Case - All Already Complete

$ Input: flowers = [5,5,5], newFlowers = 5, target = 5, full = 3, partial = 2

› Output: 9

💡 Note: All gardens are already complete (≥5 flowers). No incomplete gardens exist, so partial contribution is 0. Total beauty = 3×3 + 0×2 = 9.

Constraints

1 ≤ flowers.length ≤ 10⁵
1 ≤ flowers[i], target ≤ 10⁵
1 ≤ newFlowers ≤ 10¹⁰
1 ≤ full, partial ≤ 10⁵
Key insight: newFlowers can be very large, but we never need more than n×target flowers

Asked in

The optimal approach uses sorting + enumeration + binary search. Sort gardens by flower count, enumerate the number of complete gardens (0 to n), and use binary search to find the maximum achievable minimum for incomplete gardens. The key insight is that we can try all possible numbers of complete gardens and optimize the incomplete portion separately using prefix sums for efficient cost calculation.

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Two Pointers + Prefix Sum (Optimal)	O(n² log n)	O(n)	Sort gardens, use two pointers to optimize the enumeration with prefix sums
Sorting + Binary Search + Enumeration	O(n² log(max_flowers))	O(n)	Sort gardens, enumerate complete gardens count, binary search for optimal minimum
Brute Force (Try All Distributions)	O(newFlowers^n)	O(n)	Try every possible way to distribute newFlowers across gardens

Sorting + Two Pointers + Prefix Sum (Optimal) — Algorithm Steps

Sort gardens by current flower count
Build prefix sum array for efficient range sum queries
Use right pointer to track complete gardens (largest values)
For each complete_count, calculate exact cost using prefix sums
Use remaining flowers to optimally raise minimum of incomplete gardens
Use binary search or greedy approach to find maximum achievable minimum
Calculate beauty = complete_count × full + optimal_min × partial
Track maximum beauty across all configurations

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort & Setup

Sort gardens: [1,3,5,7,10]. Setup prefix sums for O(1) range queries

Enumerate Complete

Try 0,1,2... complete gardens from the right (largest values)

Binary Search Min

For incomplete gardens, binary search the optimal minimum value

Calculate Beauty

Sum up complete beauty + incomplete beauty for each configuration

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

long long costToAchieveMin(int count, long long minVal, long long* prefix) {
    if (count == 0) return 0;
    long long currentSum = prefix[count];
    long long targetSum = (long long)count * minVal;
    return targetSum > currentSum ? targetSum - currentSum : 0;
}

long long maximumBeauty(int* flowers, int flowersSize, long long newFlowers, int target, int full, int partial) {
    int n = flowersSize;
    qsort(flowers, n, sizeof(int), compare);
    
    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];
    }
    
    long long maxBeauty = 0;
    
    for (int completeCount = 0; completeCount <= n; completeCount++) {
        long long costForComplete = 0;
        int startComplete = n - completeCount;
        
        for (int i = startComplete; i < n; i++) {
            if (flowers[i] < target) {
                costForComplete += target - flowers[i];
            }
        }
        
        if (costForComplete > newFlowers) break;
        
        long long remainingFlowers = newFlowers - costForComplete;
        int incompleteCount = n - completeCount;
        
        long long beauty;
        if (incompleteCount == 0) {
            beauty = (long long)completeCount * full;
        } else {
            long long left = flowers[0];
            long long right = target - 1;
            if (flowers[incompleteCount - 1] + remainingFlowers < right) {
                right = flowers[incompleteCount - 1] + remainingFlowers;
            }
            long long optimalMin = flowers[0];
            
            while (left <= right) {
                long long mid = (left + right) / 2;
                long long cost = costToAchieveMin(incompleteCount, mid, prefix);
                
                if (cost <= remainingFlowers) {
                    optimalMin = mid;
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }
            
            beauty = (long long)completeCount * full + optimalMin * partial;
        }
        
        if (beauty > maxBeauty) {
            maxBeauty = beauty;
        }
    }
    
    free(prefix);
    return maxBeauty;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

O(n log n) for sorting, O(n) for two pointers enumeration, O(n log n) for binary search within each iteration

⚠ Quadratic Growth

Space Complexity

O(n)

Space for sorted array and prefix sum array

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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