The above comment for max tower height should be correct. Take the maximum value and add d.

For min I think the answer is stuck between two cases. If d is > n/2 some elements might always be in part of an update operation. Think about how any update on n=3, m=2 will cover the middle element. So the cases are between if that element will be updated in all updates and if it wont. You first take the min of all of the elements that are not guaranteed to be in an update operation, since you can just do all d updates on some range that doesn't involve it. Then you take the min out of all of the elements that have to be in an update and add d to it. The answer should be the min of the two. Here's an example

n=3, m=2, d=1

[3, 1, 2]

so 3 and 2 are not guaranteed to be in an update so we have min(2, 3) = 2, then 1 is guaranteed to be in an update so we have min(2, 1+d = 1+1 = 2) = 2 so the answer would be 2. If arr[2] had been 0, the answer would have been 1.

I think this is correct, and I hope it helps.

Maximum: $$$max(h_i) + d$$$.

Minimum: Binary search for the answer.

Let's guess that the answer is $$$V$$$ or less. This means we have to be able to add 1 to an m-sized interval $$$d$$$ times, without any tower being taller than V. This is trivially not possible if we already have a tower taller than $$$V$$$; otherwise, for each tower of heigh $$$h_i$$$ we know how many 'addition intervals' it can be included in, $$$V-h_i$$$. Let's call these leftover values $$$a_i$$$.

Consider the first tower with value $$$a_1$$$. The only way to include this tower in an addition is to add 1 to $$$h_1, h_2, ..., h_m$$$, equivalent to subtracting from $$$a_1, ..., a_m$$$, which we can if $$$min(a_1, ..., a_m) \gt 0$$$. A necessary observation is that we can't go wrong by doing this.

Proof: let's assume instead of subtracting from $$$a_1,...,a_m$$$ we instead subtract from $$$a_k, ..., a_m, ..., a_{k+m}$$$ for some $$$k \leq m$$$, and that this is an optimal solution. Then we can 'undo' this operation, adding 1 to $$$[a_k, a_{k+m}]$$$, and apply it instead to $$$[a_1, a_m]$$$ (which we can, since we just added 1 to $$$a_k, ..., a_m$$$, so their min > 0).

So we count $$$operationsDone += min(a_1,...,a_m)$$$, and subtract this minimum from $$$a_1,...a_m$$$. We move on to the interval $$$[a_2,a_{m+1}]$$$ where the same logic applies again — find minimum of $$$[a_2,a_{m+1}]$$$, add it to operations done, subtract it from those elements, and move on, until we reach the end of the array.

If we manage to get $$$operationsDone \geq d$$$, the answer is $$$V$$$ or less (we managed to do at least $$$d$$$ operations without any tower being taller than $$$V$$$, otherwise it's $$$V+1$$$ or more. Binary search until we know exactly what the answer is.

To do the above operations quickly (find minimum and subtract value from range), you can use a lazy segment tree. The entire thing would then run in $$$O(nlogn \cdot log(d+h_i))$$$ (We binary search the answer between 0 and $$$d+max(h_i)$$$, and each pass takes $$$nlogn$$$ time to check).

There might be solutions where you can cut some logs away, but this would pass TL on a contest.

Binary search on lowest possible max height. We know the final sum heights d*m+h1+h2.....

We can check if we can achieve the sum while maintaining our maximum and increasing each number by atmost d.

#include <bits/stdc++.h>
using namespace std;
int main(){
   ios_base::sync_with_stdio(false); 
   cin.tie(NULL);
   int n,m,d,mx=0,sum=0;
   cin>>n>>m>>d;
   int h[n];
   for(int i=0;i<n;i++) cin>>h[i];
   for(int i=0;i<n;i++){
    mx=max(mx,h[i]);
    sum+=h[i];
   }
   cout<<mx+d<<" ";
   int lo=mx,hi=1e9;
   while(lo<hi){
    int mid=(lo+hi)/2;
    int s=0;
    for(int i=0;i<n;i++){
        s+=min(h[i]+d,mid);
    }
    if(s>=sum) hi=mid;
    else lo=mid+1;
   }
   cout<<lo<<"\n";
   return 0;
}

Use ternary search and priority_queue to solve the minimum.