feat: add solutions to lc problem: No.2528 (#4802)

Author: yanglbme

solution/2500-2599/2528.Maximize the Minimum Powered City/README.md

@@ -203,24 +203,24 @@ class Solution {
 public:
     long long maxPower(vector<int>& 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<i32>, 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
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/2500-2599/2528.Maximize the Minimum Powered City/README_EN.md

@@ -45,8 +45,8 @@ tags:
 <pre>
 <strong>Input:</strong> stations = [1,2,4,5,0], r = 1, k = 2
 <strong>Output:</strong> 5
-<strong>Explanation:</strong> 
-One of the optimal ways is to install both the power stations at city 1. 
+<strong>Explanation:</strong>
+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.
 <pre>
 <strong>Input:</strong> stations = [4,4,4,4], r = 0, k = 3
 <strong>Output:</strong> 4
-<strong>Explanation:</strong> 
+<strong>Explanation:</strong>
 It can be proved that we cannot make the minimum power of a city greater than 4.
 </pre>
 
@@ -201,24 +201,24 @@ class Solution {
 public:
     long long maxPower(vector<int>& 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<i32>, 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
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/2500-2599/2528.Maximize the Minimum Powered City/Solution.cpp

@@ -2,24 +2,24 @@ class Solution {
 public:
     long long maxPower(vector<int>& 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;
     }
-};
+};

solution/2500-2599/2528.Maximize the Minimum Powered City/Solution.rs

@@ -0,0 +1,51 @@
+impl Solution {
+    pub fn max_power(stations: Vec<i32>, 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
+    }
+}