From eed1d261343326ff71e7f675dd34ad5480ee9a80 Mon Sep 17 00:00:00 2001 From: Libin YANG Date: Tue, 28 Oct 2025 07:30:52 +0800 Subject: [PATCH] feat: add solutions to lc problem: No.2528 --- .../README.md | 70 +++++++++++++++-- .../README_EN.md | 76 ++++++++++++++++--- .../Solution.cpp | 16 ++-- .../Solution.rs | 51 +++++++++++++ 4 files changed, 188 insertions(+), 25 deletions(-) create mode 100644 solution/2500-2599/2528.Maximize the Minimum Powered City/Solution.rs diff --git a/solution/2500-2599/2528.Maximize the Minimum Powered City/README.md b/solution/2500-2599/2528.Maximize the Minimum Powered City/README.md index f70c3aa6490df..d3a10576dbd0f 100644 --- a/solution/2500-2599/2528.Maximize the Minimum Powered City/README.md +++ b/solution/2500-2599/2528.Maximize the Minimum Powered City/README.md @@ -203,24 +203,24 @@ class Solution { public: long long maxPower(vector& stations, int r, int k) { int n = stations.size(); - long d[n + 1]; + long long d[n + 1]; memset(d, 0, sizeof d); for (int i = 0; i < n; ++i) { int left = max(0, i - r), right = min(i + r, n - 1); d[left] += stations[i]; d[right + 1] -= stations[i]; } - long s[n + 1]; + long long s[n + 1]; s[0] = d[0]; for (int i = 1; i < n + 1; ++i) { s[i] = s[i - 1] + d[i]; } - auto check = [&](long x, int k) { + auto check = [&](long long x, int k) { memset(d, 0, sizeof d); - long t = 0; + long long t = 0; for (int i = 0; i < n; ++i) { t += d[i]; - long dist = x - (s[i] + t); + long long dist = x - (s[i] + t); if (dist > 0) { if (k < dist) { return false; @@ -235,9 +235,9 @@ public: } return true; }; - long left = 0, right = 1e12; + long long left = 0, right = 1e12; while (left < right) { - long mid = (left + right + 1) >> 1; + long long mid = (left + right + 1) >> 1; if (check(mid, k)) { left = mid; } else { @@ -353,6 +353,62 @@ function maxPower(stations: number[], r: number, k: number): number { } ``` +#### Rust + +```rust +impl Solution { + pub fn max_power(stations: Vec, r: i32, k: i32) -> i64 { + let n = stations.len(); + let mut d = vec![0i64; n + 2]; + for i in 0..n { + let left = i.saturating_sub(r as usize); + let right = (i + r as usize).min(n - 1); + d[left] += stations[i] as i64; + d[right + 1] -= stations[i] as i64; + } + + let mut s = vec![0i64; n + 1]; + s[0] = d[0]; + for i in 1..=n { + s[i] = s[i - 1] + d[i]; + } + + let check = |x: i64, mut k: i64| -> bool { + let mut d = vec![0i64; n + 2]; + let mut t = 0i64; + for i in 0..n { + t += d[i]; + let dist = x - (s[i] + t); + if dist > 0 { + if k < dist { + return false; + } + k -= dist; + let j = (i + r as usize).min(n - 1); + let left = j.saturating_sub(r as usize); + let right = (j + r as usize).min(n - 1); + d[left] += dist; + d[right + 1] -= dist; + t += dist; + } + } + true + }; + + let (mut left, mut right) = (0i64, 1_000_000_000_000i64); + while left < right { + let mid = (left + right + 1) >> 1; + if check(mid, k as i64) { + left = mid; + } else { + right = mid - 1; + } + } + left + } +} +``` + diff --git a/solution/2500-2599/2528.Maximize the Minimum Powered City/README_EN.md b/solution/2500-2599/2528.Maximize the Minimum Powered City/README_EN.md index 5092ff56c0de0..ed373675abf77 100644 --- a/solution/2500-2599/2528.Maximize the Minimum Powered City/README_EN.md +++ b/solution/2500-2599/2528.Maximize the Minimum Powered City/README_EN.md @@ -45,8 +45,8 @@ tags: 
 Input: stations = [1,2,4,5,0], r = 1, k = 2
 Output: 5
-Explanation: 
-One of the optimal ways is to install both the power stations at city 1. 
+Explanation:
+One of the optimal ways is to install both the power stations at city 1.
 So stations will become [1,4,4,5,0].
 - City 0 is provided by 1 + 4 = 5 power stations.
 - City 1 is provided by 1 + 4 + 4 = 9 power stations.
@@ -62,7 +62,7 @@ Since it is not possible to obtain a larger power, we return 5.
 
 Input: stations = [4,4,4,4], r = 0, k = 3
 Output: 4
-Explanation: 
+Explanation:
 It can be proved that we cannot make the minimum power of a city greater than 4.
 

 
@@ -201,24 +201,24 @@ class Solution {
 public:
     long long maxPower(vector& stations, int r, int k) {
         int n = stations.size();
-        long d[n + 1];
+        long long d[n + 1];
         memset(d, 0, sizeof d);
         for (int i = 0; i < n; ++i) {
             int left = max(0, i - r), right = min(i + r, n - 1);
             d[left] += stations[i];
             d[right + 1] -= stations[i];
         }
-        long s[n + 1];
+        long long s[n + 1];
         s[0] = d[0];
         for (int i = 1; i < n + 1; ++i) {
             s[i] = s[i - 1] + d[i];
         }
-        auto check = [&](long x, int k) {
+        auto check = [&](long long x, int k) {
             memset(d, 0, sizeof d);
-            long t = 0;
+            long long t = 0;
             for (int i = 0; i < n; ++i) {
                 t += d[i];
-                long dist = x - (s[i] + t);
+                long long dist = x - (s[i] + t);
                 if (dist > 0) {
                     if (k < dist) {
                         return false;
@@ -233,9 +233,9 @@ public:
             }
             return true;
         };
-        long left = 0, right = 1e12;
+        long long left = 0, right = 1e12;
         while (left < right) {
-            long mid = (left + right + 1) >> 1;
+            long long mid = (left + right + 1) >> 1;
             if (check(mid, k)) {
                 left = mid;
             } else {
@@ -351,6 +351,62 @@ function maxPower(stations: number[], r: number, k: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn max_power(stations: Vec, r: i32, k: i32) -> i64 {
+        let n = stations.len();
+        let mut d = vec![0i64; n + 2];
+        for i in 0..n {
+            let left = i.saturating_sub(r as usize);
+            let right = (i + r as usize).min(n - 1);
+            d[left] += stations[i] as i64;
+            d[right + 1] -= stations[i] as i64;
+        }
+
+        let mut s = vec![0i64; n + 1];
+        s[0] = d[0];
+        for i in 1..=n {
+            s[i] = s[i - 1] + d[i];
+        }
+
+        let check = |x: i64, mut k: i64| -> bool {
+            let mut d = vec![0i64; n + 2];
+            let mut t = 0i64;
+            for i in 0..n {
+                t += d[i];
+                let dist = x - (s[i] + t);
+                if dist > 0 {
+                    if k < dist {
+                        return false;
+                    }
+                    k -= dist;
+                    let j = (i + r as usize).min(n - 1);
+                    let left = j.saturating_sub(r as usize);
+                    let right = (j + r as usize).min(n - 1);
+                    d[left] += dist;
+                    d[right + 1] -= dist;
+                    t += dist;
+                }
+            }
+            true
+        };
+
+        let (mut left, mut right) = (0i64, 1_000_000_000_000i64);
+        while left < right {
+            let mid = (left + right + 1) >> 1;
+            if check(mid, k as i64) {
+                left = mid;
+            } else {
+                right = mid - 1;
+            }
+        }
+        left
+    }
+}
+```
+
 
 
 
diff --git a/solution/2500-2599/2528.Maximize the Minimum Powered City/Solution.cpp b/solution/2500-2599/2528.Maximize the Minimum Powered City/Solution.cpp
index e539c5cf27a4f..41d90cb196eac 100644
--- a/solution/2500-2599/2528.Maximize the Minimum Powered City/Solution.cpp	
+++ b/solution/2500-2599/2528.Maximize the Minimum Powered City/Solution.cpp	
@@ -2,24 +2,24 @@ class Solution {
 public:
     long long maxPower(vector& stations, int r, int k) {
         int n = stations.size();
-        long d[n + 1];
+        long long d[n + 1];
         memset(d, 0, sizeof d);
         for (int i = 0; i < n; ++i) {
             int left = max(0, i - r), right = min(i + r, n - 1);
             d[left] += stations[i];
             d[right + 1] -= stations[i];
         }
-        long s[n + 1];
+        long long s[n + 1];
         s[0] = d[0];
         for (int i = 1; i < n + 1; ++i) {
             s[i] = s[i - 1] + d[i];
         }
-        auto check = [&](long x, int k) {
+        auto check = [&](long long x, int k) {
             memset(d, 0, sizeof d);
-            long t = 0;
+            long long t = 0;
             for (int i = 0; i < n; ++i) {
                 t += d[i];
-                long dist = x - (s[i] + t);
+                long long dist = x - (s[i] + t);
                 if (dist > 0) {
                     if (k < dist) {
                         return false;
@@ -34,9 +34,9 @@ class Solution {
             }
             return true;
         };
-        long left = 0, right = 1e12;
+        long long left = 0, right = 1e12;
         while (left < right) {
-            long mid = (left + right + 1) >> 1;
+            long long mid = (left + right + 1) >> 1;
             if (check(mid, k)) {
                 left = mid;
             } else {
@@ -45,4 +45,4 @@ class Solution {
         }
         return left;
     }
-};
\ No newline at end of file
+};
diff --git a/solution/2500-2599/2528.Maximize the Minimum Powered City/Solution.rs b/solution/2500-2599/2528.Maximize the Minimum Powered City/Solution.rs
new file mode 100644
index 0000000000000..2418c9e021fa3
--- /dev/null
+++ b/solution/2500-2599/2528.Maximize the Minimum Powered City/Solution.rs	
@@ -0,0 +1,51 @@
+impl Solution {
+    pub fn max_power(stations: Vec, r: i32, k: i32) -> i64 {
+        let n = stations.len();
+        let mut d = vec![0i64; n + 2];
+        for i in 0..n {
+            let left = i.saturating_sub(r as usize);
+            let right = (i + r as usize).min(n - 1);
+            d[left] += stations[i] as i64;
+            d[right + 1] -= stations[i] as i64;
+        }
+
+        let mut s = vec![0i64; n + 1];
+        s[0] = d[0];
+        for i in 1..=n {
+            s[i] = s[i - 1] + d[i];
+        }
+
+        let check = |x: i64, mut k: i64| -> bool {
+            let mut d = vec![0i64; n + 2];
+            let mut t = 0i64;
+            for i in 0..n {
+                t += d[i];
+                let dist = x - (s[i] + t);
+                if dist > 0 {
+                    if k < dist {
+                        return false;
+                    }
+                    k -= dist;
+                    let j = (i + r as usize).min(n - 1);
+                    let left = j.saturating_sub(r as usize);
+                    let right = (j + r as usize).min(n - 1);
+                    d[left] += dist;
+                    d[right + 1] -= dist;
+                    t += dist;
+                }
+            }
+            true
+        };
+
+        let (mut left, mut right) = (0i64, 1_000_000_000_000i64);
+        while left < right {
+            let mid = (left + right + 1) >> 1;
+            if check(mid, k as i64) {
+                left = mid;
+            } else {
+                right = mid - 1;
+            }
+        }
+        left
+    }
+}