From cb659dfad453080bf6ec01f172b6efeda520d9e2 Mon Sep 17 00:00:00 2001
From: chayan das <dasshuvo817@gmail.com>
Date: Fri, 7 Nov 2025 23:26:08 +0530
Subject: [PATCH] Create 2528. Maximize the Minimum Powered City

---
 2528. Maximize the Minimum Powered City | 63 +++++++++++++++++++++++++
 1 file changed, 63 insertions(+)
 create mode 100644 2528. Maximize the Minimum Powered City

diff --git a/2528. Maximize the Minimum Powered City b/2528. Maximize the Minimum Powered City
new file mode 100644
index 0000000..cbbecd2
--- /dev/null
+++ b/2528. Maximize the Minimum Powered City	
@@ -0,0 +1,63 @@
+class Solution {
+public:
+    vector<long long> diffArray;    // For efficient range updates
+    vector<long long> cityPower;    // Current power in each city
+    int n;
+
+    // Check if we can make every city's power at least `target`
+    bool canAchieve(long long target, int r, long long kAvailable) {
+        fill(diffArray.begin(), diffArray.end(), 0);
+        long long runningAdd = 0;
+
+        for (int i = 0; i < n; i++) {
+            runningAdd += diffArray[i];
+            long long currentPower = cityPower[i] + runningAdd;
+
+            if (currentPower < target) {
+                long long need = target - currentPower;
+                kAvailable -= need;
+                if (kAvailable < 0) return false;
+
+                runningAdd += need;
+                if (i + 2 * r + 1 < n)
+                    diffArray[i + 2 * r + 1] -= need;
+            }
+        }
+        return true;
+    }
+
+    long long maxPower(vector<int>& stations, int r, int k) {
+        n = stations.size();
+        cityPower.assign(n, 0);
+        diffArray.assign(n, 0);
+
+        // Step 1: Compute total initial power per city (range effect)
+        vector<long long> prefix(n + 1, 0);
+        for (int i = 0; i < n; i++)
+            prefix[i + 1] = prefix[i] + stations[i];
+
+        for (int i = 0; i < n; i++) {
+            int left = max(0, i - r);
+            int right = min(n - 1, i + r);
+            cityPower[i] = prefix[right + 1] - prefix[left];
+        }
+
+        // Step 2: Binary search for the maximum possible minimum power
+        long long low = *min_element(cityPower.begin(), cityPower.end());
+        long long high = *max_element(cityPower.begin(), cityPower.end()) + k;
+        long long best = 0;
+
+        while (low <= high) {
+            long long mid = low + (high - low) / 2;
+
+            if (canAchieve(mid, r, k)) {
+                best = mid;
+                low = mid + 1;
+            } else {
+                high = mid - 1;
+            }
+        }
+
+        return best;
+    }
+};