let's say index $$$i$$$ is special if and only if $$$a_{i+1} - a_{i} > k_{i}$$$

at each update, we say index i changed state if and only if it was special before the update and after the update it's not special, or if it wasn't special before the update and after the update, it became special (i.e, the special status of $$$i$$$ flipped).

let $$$t_i$$$ be the total number of indices that changed state in the $$$i$$$'th update.

Claim: $$$\sum_{i=1}^{q}{t_i} = O(n+q)$$$ (i.e, the total number of changes in all updates is linear)

Proof: At each update, at most one index becomes special. If $$$i > 0$$$ & $$$i-1$$$ was not special & $$$x>0$$$, then $$$i-1$$$ becomes special. I claim all other indices don't become special if they weren't. All indices $$$ < i-1$$$ trivially don't change state as they don't change value. Indicies $$$> i$$$ are only updated because of carrying and the need for the difference to be exactly k, namely no difference $$$> k$$$ is ever being created therefore non of these indices will become special. so the total number of indices that become special is in the worst-case $$$O(q)$$$, and we initially start in the worst case with $$$O(n)$$$ special indices. Each change of special -> not special requires the index to have been special and the total number of things becoming special or initially being special is $$$O(n+q)$$$ therefore the total number of these differences (special-> non-special) is also $$$O(n+q)$$$ in the worst case, therefore, the total number of changes is $$$O(n+q)$$$ and we are done. $$$\blacksquare$$$

How do we use this fact? The main observation is that in order to update a continuous range of nonspecial indices, we simply need to add X to all of them.

we maintain the division of the array indices into segments in which all elements are not special except the last element. We also maintain a data structure (in my code, a lazy segment tree) that supports range add & range sum query. for an update, we initially find the segment the updated index belongs to, if the element before it is in the same segment (i.e it's not special), we split the segment into two segments accordingly (where i-1 is the last element in the left split part). we update all elements with an index bigger than or equal to it that are not the last element by doing a range add on our data structure. then for the last element in the segment, we add to it the maximum value we can such that the difference is >= k and subtract what we added from the variable that stores the amount we need to add. if it became nonspecial we merge the segment and the segment after it if it exists and then we recursively solve again if we still have something to add. Now the beautiful part: because of our observation, the total number of merges and splits will be $$$O(n+q)$$$, therefore the complexity of this solution is $$$O((n+q)\log(n))$$$ $$$\blacksquare$$$. I initially left some of the details in this part vague in order to let you explore and see the beauty in utilizing these two observations. Note that the definition of special only depends on current k, therefore, updating k values is easy.