先考虑不修改怎么做，可以令 \(dp_i\) 表示前 \(i\) 个题能获得的最大得分。那么我们有转移：

\[dp_i = \min\{dp_{i - 1}, dp_{j} + \frac{(i - j + 1)(i - j)}{2} - (S_i - S_j)\}(0 \le j < i)
\]

很显然后面那部分是一个斜优的形式，我们化一下柿子可以得到：

\[dp_j + \frac{j(j - 1)}{2} + S_j = ij + dp_i + S_i - \frac{i(i + 1)}{2}
\]

可以发现我们需要维护一个上凸包的形式，每次查询的斜率单调递增，加入凸包的点单调递增，可以使用单调栈完成这个操作。

接下来再考虑修改，不难发现每次我们修改的这个位置可能是选或不选两种状态，对于后者我们只需维护出 \(f_i\) 表示 \(1 \sim i\) 这些题能获得的最大得分和 \(g_i\) 表示 \(i \sim n\) 这些题的最大得分，那么不选这个题的最大得分就是 \(f_{i - 1} + g_{i + 1}\)。

接下来我们考虑选择这个位置的情况。令 \(h_i\) 表示强制选择 \(i\) 这个位置的最大得分，考虑枚举左边第一个没有选择的位置 \(l\)，和右边第一个选择的位置 \(r\)（这样好算一些），那么有转移：

\[h_i = \min\{f_l + g_{r + 1} + \frac{(r - l + 1)(r - l)}{2} - (S_r - S_l)\}(0 \le l < i, i \le r \le n)
\]

根据这个柿子我们可以发现这样一个事实，如果我们每次修改了一个 \(T_i\) 对 \(S_l, f_l, g_{r + 1}\) 是不会有影响的，对 \(S_r\) 相当于整体加上了一个变化量，因此我们可以提前预处理出最开始序列的 \(h_i\) 那么修改某个点后必选这个位置的最大得分就是 \(h_i + \Delta\) 了。

继续考虑上面那个式子，我们化简一下式子看看这个式子还能不能斜率优化：

\[g_{r + 1} + \frac{r(r + 1)}{2} - S_r = lr + h_i - f_l - \frac{l(l - 1)}{2} - S_l
\]

可以发现我们在枚举 \(i\) 同时枚举 \(l\)，那么上面的那个式子相当于也是一个斜率优化的形式，这样我们就可以做到 \(O(n ^ 2)\) 了，但这和暴力重构的复杂度是一样的，我们还需另辟蹊径。

反过来想，我们不枚举每个 \(i\)，而是直接考虑 \(l, r\) 对中间每个 \(i\) 的贡献。可以发现这样的 \((l, r)\) 其实是一个点对的形式，于是我们可以考虑使用 \(\rm CDQ\) 分治来优化这个过程。

具体来讲，假设当前分治考虑的区间为 \([L, R]\)，那么我们当前值考虑 \(l\) 在 \([L, Mid]\)，\(r\) 在 \([Mid + 1, R]\) 的点对 \((l, R)\)，这样显然是能包含所有点对的。根据上面那个式子，我们依然需要枚举每个 \(l\)，只是我们惊奇地发现我们的右端点的范围其实已经确定，那么每次在枚举 \(l\) 之前我们先将右半边区间的所有 \(r\) 都插入到上凸包中，那么我们从左往右地去枚举每个 \(l\)，斜率单调递增，依然可以直接使用单调栈解决。不难发现我们这里求出的每个 \(l\) 的答案可以对 \([l + 1, Mid]\) 中的所有 \(h_i\) 造成贡献，反过来每个 \(i\) 可以被 \([L - 1, i - 1]\) 的 \(l\) 造成贡献，于是我们只需要记录一个前缀 \(\max\) 就可以了。但这样我们只能计算对 \([L, Mid]\) 中的点的贡献，那么对 \([Mid + 1, R]\) 中点的贡献怎么算呢？我们只需要将这个区间反过来，将 \(r\) 看作 \(l\) 将 \(l\) 看作 \(r\) 做一遍一样的流程即可。

注意因为我们要保证斜率优化的决策单调性，因此我们每次枚举的斜率 \(l\) 要单调递增，每次插入凸包中的点 \(i\) 横坐标即下边也要单调递增，这意味着我们都要从小到大地去枚举。

#include<bits/stdc++.h>
using namespace std;
#define N 300000 + 5
#define int long long
#define mid (l + r) / 2
#define inf 10000000000000000
#define rep(i, l, r) for(int i = l; i <= r; ++i)
#define dep(i, l, r) for(int i = r; i >= l; --i)
typedef double D;
int n, m, P, X, top, f[N], g[N], h[N], t[N], T[N], S1[N], S2[N], st[N], mx[N];
int read(){
    char c; int x = 0, f = 1;
    c = getchar();
    while(c > '9' || c < '0'){ if(c == '-') f = -1; c = getchar();}
    while(c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
    return x * f;
}
int Y1(int x){
    return f[x] + x * (x - 1) / 2 + S1[x];
}
int Y2(int x){
    return g[x] + x * (x - 1) / 2 + S2[x];
}
int Y3(int x){
    return x * (x + 1) / 2 - S1[x] + g[x + 1];
}
int Y4(int x){
    return x * (x - 1) / 2 + S1[x] + f[x];
}
D slope1(int a, int b){
    return 1.0 * (Y1(a) - Y1(b)) / (a - b);
}
D slope2(int a, int b){
    return 1.0 * (Y2(a) - Y2(b)) / (a - b);
}
D slope3(int a, int b){
    return 1.0 * (Y3(a) - Y3(b)) / (a - b);
}
D slope4(int a, int b){
    return 1.0 * (Y4(a) - Y4(b)) / (a - b);
}
void solve(int l, int r){
    if(l == r){ h[l] = max(h[l], f[l - 1] + g[l + 1] + 1 - T[l]); return;}
    solve(l, mid), solve(mid + 1, r);
    st[top = 1] = mid + 1;
    rep(i, mid + 2, r){
        while(top > 1 && slope3(st[top], st[top - 1]) < slope3(st[top - 1], i)) --top;
        st[++top] = i;
    }
    rep(i, l - 1, mid - 1){
        while(top > 1 && i > slope3(st[top], st[top - 1])) --top;
        t[i] = f[i] + (st[top] - i + 1) * (st[top] - i) / 2 + g[st[top] + 1] - S1[st[top]] + S1[i];
    }
    mx[l - 1] = -inf;
    rep(i, l, mid) mx[i] = max(mx[i - 1], t[i - 1]), h[i] = max(h[i], mx[i]);
    st[top = 1] = l - 1;
    rep(i, l, mid - 1){
        while(top > 1 && slope4(st[top], st[top - 1]) < slope4(st[top - 1], i)) --top;
        st[++top] = i;
    }
    rep(i, mid + 1, r){
        while(top > 1 && i > slope4(st[top], st[top - 1])) --top;
        t[i] = g[i + 1] + (i - st[top] + 1) * (i - st[top]) / 2 + f[st[top]] - S1[i] + S1[st[top]];
    }
    mx[r + 1] = -inf;
    dep(i, mid + 1, r) mx[i] = max(mx[i + 1], t[i]), h[i] = max(h[i], mx[i]);
}
signed main(){
    n = read();
    rep(i, 1, n) T[i] = read(), S1[i] = S1[i - 1] + T[i], h[i] = -inf;
    dep(i, 1, n) S2[n - i + 1] = S2[n - i] + T[i];
    st[++top] = 0;
    rep(i, 1, n){
        while(top > 1 && i > slope1(st[top], st[top - 1])) --top;
        f[i] = max(f[i - 1], f[st[top]] + (i - st[top] + 1) * (i - st[top]) / 2 + S1[st[top]] - S1[i]);
        while(top > 1 && slope1(st[top], st[top - 1]) < slope1(st[top - 1], i)) --top;
        st[++top] = i;
    }
    st[top = 1] = 0;
    rep(i, 1, n){
        while(top > 1 && i > slope2(st[top], st[top - 1])) --top;
        g[i] = max(g[i - 1], g[st[top]] + (i - st[top] + 1) * (i - st[top]) / 2 + S2[st[top]] - S2[i]);
        while(top > 1 && slope2(st[top], st[top - 1]) < slope2(st[top - 1], i)) --top;
        st[++top] = i;
    }
    reverse(g + 1, g + n + 1);
    solve(1, n);
    m = read();
    while(m--) P = read(), X = read(), printf("%lld\n", max(f[P - 1] + g[P + 1], h[P] + T[P] - X));
    return 0;
}