#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <set>

int main()
{
    /*
    Для чтения входных данных необходимо получить их
    из стандартного потока ввода (stdin).
    Данные во входном потоке соответствуют описанному
    в условии формату. Обычно входные данные состоят
    из нескольких строк.

    Можно использовать несколько методов:
    * std::cin -- читает токены из потока;
    * std::getline() -- читает одну строку из потока;
    * scanf()/gets() -- C-функции для чтения из stdin.

    Чтобы прочитать из строки стандартного потока:
    * число -- int var; std::cin >> var;
    * строку -- std::string svar; std::cin >> svar;
    * массив чисел известной длины --
    std::vector<int> arr(len);
    for (size_t i = 0; i < arr.size(); ++i)
        std::cin >> arr[i];
    * последовательность слов до конца файла --
    std::vector<std::string> sarr;
    std::string word;
    while (std::cin >> word) {
        sarr.push_back(word);
    }

    Чтобы вывести результат в стандартный поток вывода (stdout),
    можно использовать поток std::cout.

    Возможное решение задачи "Вычислите сумму A+B":
    int a, b;
    std::cin >> a >> b;
    std::cout << a + b << std::endl;
    */
    int N;
    std::cin >> N;

    std::vector<std::pair<int, int>> skills(N);
    for (auto &[a, b] : skills)
        std::cin >> a;
    for (auto &[a, b] : skills)
        std::cin >> b;

    std::vector<std::pair<int, int>> diffs;
    for (size_t i = 0; i < N; ++i)
        diffs.emplace_back(skills[i].first - skills[i].second, i);
    std::sort(diffs.begin(), diffs.end());

    std::set<std::pair<int, int>> programmers;
    std::set<std::pair<int, int>> managers;

    size_t programmersSum = 0;
    size_t managersSum = 0;

    for (size_t i = 0; i < diffs.size() / 2; ++i)
    {
        managers.insert(diffs[i]);
        managersSum += skills[diffs[i].second].second;
    }
    for (size_t i = diffs.size() / 2; i < diffs.size(); ++i)
    {
        programmers.insert(diffs[i]);
        programmersSum += skills[diffs[i].second].first;
    }

    int M;
    std::cin >> M;
    for (size_t i = 0; i < M; ++i)
    {
        int num, type, d;
        std::cin >> num >> type >> d;

        num -= 1;

        auto a = skills[num].first, b = skills[num].second;
        int newA = a, newB = b;
        if (type == 1)
            newA += d;
        else
            newB += d;

        skills[num] = {newA, newB};

        std::pair<int, int> key(a - b, num);
        std::pair<int, int> newKey(newA - newB, num);

        if (auto it = programmers.find(key); it != programmers.end())
        {
            programmers.erase(*it);
            programmersSum -= a;

            auto bestManager = *(managers.rbegin());
            if (bestManager.first < newKey.first)
            {
                programmers.insert(newKey);
                programmersSum += newA;
            }
            else
            {
                managers.erase(bestManager);
                managersSum -= skills[bestManager.second].second;
                managers.insert(newKey);
                managersSum += newB;

                programmers.insert(bestManager);
                programmersSum += skills[bestManager.second].first;
            }
        }
        else if (auto it = managers.find(key); it != managers.end())
        {
            managers.erase(*it);
            managersSum -= b;

            auto worstProgrammer = *(programmers.begin());
            if (worstProgrammer.first > newKey.first)
            {
                managers.insert(newKey);
                managersSum += newB;
            }
            else
            {
                programmers.erase(worstProgrammer);
                programmersSum -= skills[worstProgrammer.second].first;
                programmers.insert(newKey);
                programmersSum += newA;

                managers.insert(worstProgrammer);
                managersSum -= skills[worstProgrammer.second].second;
            }
        }
        else
            return 1;

        std::cout << programmersSum + managersSum << '\n';
    }

    return 0;
}