[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

content/6_Advanced/Lagrange.mdx

@@ -25,17 +25,17 @@ frequency: 1
 
 ## Lagrangian Relaxation
 
-Lagrangian Relaxation involves transforming a constraint on a variable into a cost $\lambda$ and binary searching for the optimal $\lambda$. 
+Lagrangian Relaxation involves transforming a constraint on a variable into a cost $\lambda$ and binary searching for the optimal $\lambda$.
 
 <FocusProblem problem="sample" />
 
 The problem gives us a length $N$ ($1 \le N \le 3 \cdot 10^5$) array of integers in the range $[-10^9,10^9]$. We are given some $K$ ($1 \le K \le N$) and are asked to choose at most $K$ disjoint subarrays such that the sum of elements included in a subarray is maximized.
 
 ### Intuition
 
-The main bottleneck of any dynamic programming solution to this problem is having to store the number of subarrays we have created so far. 
+The main bottleneck of any dynamic programming solution to this problem is having to store the number of subarrays we have created so far.
 
-Let's try to find a way around this. Instead of storing the number of subarrays we have created so far, we assign a penalty of $\lambda$ for creating a new subarray (i.e. everytime we create a subarray we penalize our sum by $\lambda$). 
+Let's try to find a way around this. Instead of storing the number of subarrays we have created so far, we assign a penalty of $\lambda$ for creating a new subarray (i.e. everytime we create a subarray we penalize our sum by $\lambda$).
 
 This leads us to the sub-problem of finding the maximal sum and number of subarrays used if creating a new subarray costs $\lambda$. We can solve this in $\mathcal{O}(N)$ time with dynamic programming.
 
@@ -72,7 +72,7 @@ This idea almost works but there are still some very important caveats and condi
 
 ### Geometry
 
-Let $f(x)$ be the maximal sum if we use at most $x$ subarrays. We want to find $f(K)$. 
+Let $f(x)$ be the maximal sum if we use at most $x$ subarrays. We want to find $f(K)$.
 
 The first condition is that $f(x)$ **must be concave or convex**. Since $f(x)$ is increasing in this problem, the means that we need $f(x)$ to be concave: $f(x) - f(x - 1) \ge f(x + 1) - f(x)$. In other words, this means that the more subarrays we add, the less we increase our answer by. We can intuitively see that this is true.
 
@@ -103,7 +103,7 @@ Here is where the fact that $f(x)$ is concave comes in. Because the slope is non
 
 Let $v(\lambda)$ be the optimal maximal achievable sum with $\lambda$ penalty and $c(\lambda)$ be the number of subarrays used to achieve $v(\lambda)$ (note that if there are multiple such possibilities, we set $c$ to be the **minimal** number of subarrays to achieve $v$). These values can be calculated in $\mathcal{O}(N)$ time using the dynamic programming approach described above.
 
-When we assign the penalty of $\lambda$, we are trying to find the maximal sum if creating a subarray reduces our sum by $\lambda$. In other words, **we are trying to find the maximum of $f(x) - \lambda x$**. 
+When we assign the penalty of $\lambda$, we are trying to find the maximal sum if creating a subarray reduces our sum by $\lambda$. In other words, **we are trying to find the maximum of $f(x) - \lambda x$**.
 
 Without loss of generality, suppose there exists a slope equal to $\lambda$. Given the shape of $f(x) - \lambda x$, we know that $f(x) - \lambda x$ will be maximized at the points where $\lambda$ is equal to the slope of $f(x)$ (these points are red in the graph above). This means that $c(\lambda)$ will be the point at which $\lambda$ is equal to the slope of $f(x)$ (if there are multiple such points, then $c(\lambda)$ will be the leftmost one).
 
@@ -113,57 +113,55 @@ We binary search for $\lambda$ and find the highest $\lambda$ such that $c(\lamb
 
 Because calculating $v(\lambda)$ and $c(\lambda)$ with the dynamic programming solution described above will take $\mathcal{O}(N)$ time, this solution runs in $\mathcal{O}(N\log{\sum A[i]})$ time.
 
-```cpp 
+```cpp
 #include <bits/stdc++.h>
 using namespace std;
- 
+
 #define ll long long
 #define pll pair<ll, ll>
 #define f first
 #define s second
- 
+
 const int MAX = 3e5 + 5;
 
-int n, k, A[MAX]; pll dp[MAX][2];
- 
-pll better(pll a, pll b){
-    if (a.f == b.f) 
-        return (a.s < b.s ? a : b);
+int n, k, A[MAX];
+pll dp[MAX][2];
+
+pll better(pll a, pll b) {
+	if (a.f == b.f) return (a.s < b.s ? a : b);
 
-    return (a.f > b.f ? a : b);
+	return (a.f > b.f ? a : b);
 }
 
-bool solve(ll lmb){
-    dp[0][0] = {0, 0}; 
-    dp[0][1] = {-1e18, 0};
- 
-    for (int i = 1; i <= n; i++){
-        dp[i][0] = better(dp[i - 1][0], dp[i - 1][1]);
-
-        dp[i][1] = better(
-            {dp[i - 1][0].f + A[i] - lmb, dp[i - 1][0].s + 1}, 
-            {dp[i - 1][1].f + A[i], dp[i - 1][1].s}
-        );
-    }
-    return better(dp[n][0], dp[n][1]).s <= k;
+bool solve(ll lmb) {
+	dp[0][0] = {0, 0};
+	dp[0][1] = {-1e18, 0};
+
+	for (int i = 1; i <= n; i++) {
+		dp[i][0] = better(dp[i - 1][0], dp[i - 1][1]);
+
+		dp[i][1] = better({dp[i - 1][0].f + A[i] - lmb, dp[i - 1][0].s + 1},
+		                  {dp[i - 1][1].f + A[i], dp[i - 1][1].s});
+	}
+	return better(dp[n][0], dp[n][1]).s <= k;
 }
- 
-int main(){
-    ios_base::sync_with_stdio; cin.tie(0);
-    cin >> n >> k;
-
-    for (int i = 1; i <= n; i++) 
-        cin >> A[i];
- 
-    ll L = 0, H = 1e15;
-
-    while (L < H){
-        ll M = (L + H) / 2;
-        solve(M) ? H = M : L = M + 1;
-    }
-    solve(L);
-    
-    cout << better(dp[n][0], dp[n][1]).f + L * k << "\n";
+
+int main() {
+	ios_base::sync_with_stdio;
+	cin.tie(0);
+	cin >> n >> k;
+
+	for (int i = 1; i <= n; i++) cin >> A[i];
+
+	ll L = 0, H = 1e15;
+
+	while (L < H) {
+		ll M = (L + H) / 2;
+		solve(M) ? H = M : L = M + 1;
+	}
+	solve(L);
+
+	cout << better(dp[n][0], dp[n][1]).f + L * k << "\n";
 }
 ```
 ## Problems