#include <bits/stdc++.h>
#pragma GCC optimize("O3", "unroll-loops")
#pragma GCC target("avx")
using namespace std;
using lint = long long int;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
struct fast_ios { fast_ios(){ cin.tie(0); ios::sync_with_stdio(false); cout << fixed << setprecision(20); }; } fast_ios_;
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((lint)(x).size())
#define POW2(n) (1LL << (n))
#define FOR(i, begin, end) for(int i=(begin),i##_end_=(end);i<i##_end_;i++)
#define IFOR(i, begin, end) for(int i=(end)-1,i##_begin_=(begin);i>=i##_begin_;i--)
#define REP(i, n) FOR(i,0,n)
#define IREP(i, n) IFOR(i,0,n)
template<typename T> istream &operator>>(istream &is, vector<T> &vec){ for (auto &v : vec) is >> v; return is; }
template<typename T> ostream &operator<<(ostream &os, const vector<T> &vec){ os << "["; for (auto v : vec) os << v << ","; os << "]"; return os; }
template<typename T> ostream &operator<<(ostream &os, const deque<T> &vec){ os << "deq["; for (auto v : vec) os << v << ","; os << "]"; return os; }
template<typename T> ostream &operator<<(ostream &os, const set<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const unordered_set<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const unordered_multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T1, typename T2> ostream &operator<<(ostream &os, const pair<T1, T2> &pa){ os << "(" << pa.first << "," << pa.second << ")"; return os; }
template<typename TK, typename TV> ostream &operator<<(ostream &os, const map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << "=>" << v.second << ","; os << "}"; return os; }
template<typename TK, typename TV> ostream &operator<<(ostream &os, const unordered_map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << "=>" << v.second << ","; os << "}"; return os; }
template<typename T> void ndarray(vector<T> &vec, int len) { vec.resize(len); }
template<typename T, typename... Args> void ndarray(vector<T> &vec, int len, Args... args) { vec.resize(len); for (auto &v : vec) ndarray(v, args...); }
template<typename T> bool mmax(T &m, const T q) { if (m < q) {m = q; return true;} else return false; }
template<typename T> bool mmin(T &m, const T q) { if (m > q) {m = q; return true;} else return false; }
template<typename T1, typename T2> pair<T1, T2> operator+(const pair<T1, T2> &l, const pair<T1, T2> &r) { return make_pair(l.first + r.first, l.second + r.second); }
template<typename T1, typename T2> pair<T1, T2> operator-(const pair<T1, T2> &l, const pair<T1, T2> &r) { return make_pair(l.first - r.first, l.second - r.second); }
#define dbg(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ") " << __FILE__ << endl;


// Convex Hull Trick for monotone increasing queries, monotone decreasing slopes
// Each operation is amortized O(1)
// - add_line(a, b): Add `y = ax + b`, a must be monotone decreasing
// - add_convex_parabola(c, a, b): Add `y = c(x - a)^2 + b` (c is constant & a is monotone increasing)
// - get(x): Calculate min/max. value of `y = ax + b`'s at point x, x must be monotone increasing
// - parabola_get(c, x): Caclculate min/max. value of `y = c(x - a)^2 + b`'s
// Verified: <https://yukicoder.me/submissions/409156>
using T_CHT = long long int; // template<typename T_CHT>
struct MonotoneConvexHullTrick : std::deque<std::pair<T_CHT, T_CHT>> // (a, b) means `y = ax + b`
{
    using T_MP = __int128_t;
    bool is_minimizer; // If true, this instance calculates min. Otherwise, calculates max.
    MonotoneConvexHullTrick(bool is_minimizer) : is_minimizer(is_minimizer) {}
    void add_line(T_CHT a, T_CHT b) {  // Add y = ax + b
        if (!is_minimizer) a = -a, b = -b;
        assert(this->empty() or this->back().first > a);
        while (this->size() > 1u) {
            int sz = this->size();
            T_MP l = (T_MP)(this->back().second - (*this)[sz - 2].second) * (this->back().first - a); // Overflow might occur here.
            T_MP r = (T_MP)(b - this->back().second) * ((*this)[sz - 2].first - this->back().first);
            if (l < r) break;
            this->pop_back();
        }
        this->emplace_back(a, b);
    }
    T_CHT get(T_CHT x) {
        while (this->size() > 1u and (*this)[0].first * x + (*this)[0].second > (*this)[1].first * x + (*this)[1].second) {
            this->pop_front();
        }
        return ((*this)[0].first * x + (*this)[0].second) * (is_minimizer ? 1 : -1);
    }
    void add_convex_parabola(T_CHT c, T_CHT a, T_CHT b) { add_line(-2 * c * a, c * a * a + b); } // Add y = c(x - a)^2 + b
    T_CHT parabola_get(T_CHT c, T_CHT x) { return get(x) + c * x * x; }
};

#include <boost/multiprecision/cpp_int.hpp>
using mpint = boost::multiprecision::cpp_int;

/*
Convex Hull Trick
Implementation Idea: <https://github.com/satanic0258/Cpp_snippet/blob/master/src/technique/ConvexHullTrick.cpp>
*/
using T_CHT = long long int;
struct ConvexHullTrick
{
    static const T_CHT T_MIN = numeric_limits<T_CHT>::lowest() + 1;
    struct Line
    {
        T_CHT a, b; // y = ax + b
        mutable pair<T_CHT, T_CHT> rp; // (numerator, denominator) `x` coordinate of the crossing point with next line
        Line(T_CHT a, T_CHT b) : a(a), b(b), rp(T_MIN, T_MIN) {}
        static pair<T_CHT, T_CHT> cross(const Line &ll, const Line &lr)
        {
            return make_pair(ll.b - lr.b, lr.a - ll.a); // `ll.a < lr.a` is assumed implicitly
        }
        bool operator<(const Line &r) const
        {
            if (b == T_MIN)
            {
                if (r.rp.first == T_MIN) return true;
                else return a * r.rp.second < r.rp.first;
            }
            else if (r.b == T_MIN)
            {
                if (rp.first == T_MIN) return false;
                else return !(r.a * rp.second < rp.first);
            }
            else return a < r.a;
        }
    };
    struct Lines : multiset<Line>
    {
        bool flg_min; // true iff for minimization
        inline bool isNeedless(iterator itr)
        {
            if (size() == 1) return false;
            auto nxt = next(itr);
            if (itr == begin()) return itr->a == nxt->a and itr->b <= nxt->b;
            else
            {
                auto prv = prev(itr);
                if (nxt == end()) return itr->a == prv->a and itr->b <= prv->b;
                // Prevent overflow
                else return mpint(prv->b - itr->b) * (nxt->a - itr->a) >= mpint(itr->b - nxt->b) * (itr->a - prv->a);
            }
        }
        void add_line(T_CHT a, T_CHT b)
        {
            if (flg_min) a = -a, b = -b;
            auto itr = insert({a, b});
            if (isNeedless(itr)) erase(itr);
            else
            {
                while (next(itr) != end() and isNeedless(next(itr)))
                {
                    erase(next(itr));
                }
                while (itr != begin() and isNeedless(prev(itr)))
                {
                    erase(prev(itr));
                }
                if (next(itr) != end())
                {
                    itr->rp = Line::cross(*itr, *next(itr));
                }
                if (itr != begin())
                {
                    prev(itr)->rp = Line::cross(*prev(itr), *itr);
                }
            }
        }
        Lines(bool is_minimizer): flg_min(is_minimizer) {}
        pair<T_CHT, T_CHT> get(T_CHT x)
        {
            auto itr = lower_bound({x, T_MIN});
            T_CHT retval = T_MIN, reta = T_MIN;
            if (itr != end())
            {
                retval = itr->a * x + itr->b;
                reta = itr->a;
            }
            if (itr != begin())
            {
                T_CHT tmp = prev(itr)->a * x + prev(itr)->b;
                if (tmp >= retval)
                {
                    retval = tmp;
                    reta = max(reta, prev(itr)->a);
                }
            }
            return make_pair(flg_min ? -retval : retval, flg_min ? -reta : reta);
        }
    };
    Lines lines;
    ConvexHullTrick(bool is_minimizer) : lines(is_minimizer) {}
    void add_line(T_CHT a, T_CHT b) { lines.add_line(a, b); } // Add y = ax + b
    pair<T_CHT, T_CHT> get(T_CHT x) { return lines.get(x); }
    void add_convex_parabola(T_CHT c, T_CHT a, T_CHT b) { add_line(-2 * c * a, c * a * a + b); } // Add y = c(x - a)^2 + b
    T_CHT parabola_get(T_CHT c, T_CHT x) { return lines.get(x).first + c * x * x; }
};
const T_CHT ConvexHullTrick::T_MIN;

int N, M;
constexpr lint INF = 1e16;
vector<lint> solve_dontuse(const vector<lint> &T)
{
    ConvexHullTrick cht(false);
    vector<lint> ret(N + 1, -INF);
    ret[0] = 0;
    REP(i, N)
    {
        cht.add_convex_parabola(1, i, ret[i]);
        mmax(ret[i + 1], cht.parabola_get(1, i) + 2 * T[i] - 1);
    }
    REP(i, N) ret[i] = ret[i + 1];
    ret.pop_back();
    return ret;
}

vector<lint> dpL, dpR;
vector<vector<lint>> maxi;
vector<vector<lint>> eras;

vector<lint> T;

vector<lint> retL;
void divide_and_conquer(int L, int R)
{
    if (L >= R) return;
    if (L + 1 == R)
    {
        lint w = (L ? dpL[L - 1] : 0LL) + (L + 1 < N ? dpR[L + 1] : 0LL) + 1;
        maxi[L].push_back(w);
        eras[L + 1].push_back(w);
        return;
    }
    int C = (L + R) / 2;
    MonotoneConvexHullTrick cht(false);
    FOR(l, L, C)
    {
        cht.add_convex_parabola(1, -(l - 1), (l ? dpL[l - 1] : 0));
    }
    lint highest = -1e18;
    IFOR(r, C, R)
    {
        lint v = cht.parabola_get(1, -r) + (r < N - 1 ? dpR[r + 1] : 0);
        mmax(highest, v);
        mmax(retL[r], highest);
        // maxi[C].push_back(v);
        // eras[r + 1].push_back(v);
    }
    cht = MonotoneConvexHullTrick(false);
    IFOR(r, C, R)
    {
        cht.add_convex_parabola(1, (r + 1), (r < N - 1 ? dpR[r + 1] : 0));
    }
    highest = -1e18;
    FOR(l, L, C)
    {
        lint v = cht.parabola_get(1, l) + (l ? dpL[l - 1] : 0);
        mmax(highest, v);
        mmax(retL[l], highest);
        // maxi[l].push_back(v);
        // eras[C].push_back(v);
    }
    divide_and_conquer(L, C);
    divide_and_conquer(C, R);
}

vector<lint> solver()
{
    vector<lint> ret(N);
    map<lint, int> cou;
    REP(i, N)
    {
        for (auto v : maxi[i]) cou[v]++;
        for (auto v : eras[i])
        {
            cou[v]--;
            if (!cou[v]) cou.erase(v);
        }
        ret[i] = prev(cou.end())->first;
    }
    return ret;
}

int main()
{
    cin >> N;
    T.resize(N);
    cin >> T;
    cin >> M;
    dpL = solve_dontuse(T);
    reverse(ALL(T));
    dpR = solve_dontuse(T);
    reverse(ALL(T));
    reverse(ALL(dpR));

    maxi.resize(N + 1);
    eras.resize(N + 1);
    retL.resize(N);
    divide_and_conquer(0, N);
    // retL = solver();
    lint Ttot = accumulate(ALL(T), 0LL);
    REP(_, M)
    {
        int P;
        lint X;
        cin >> P >> X;
        P--;
        lint reta = (dpL[P] + dpR[P] - (2 * T[P] - 1) + N - 2 * Ttot) / 2;
        lint retb = (retL[P] + N - 2 * Ttot) / 2 + T[P] - X;
        lint ret = max(reta, retb);
        printf("%lld\n", ret);
    }
}


Measured memory_bytes: 45312