// https://szkopul.edu.pl/problemset/problem/FWVAF1ZpKFQnEHkbt1d5Hayl/site/?key=statement

#include <bits/stdc++.h>

using namespace std;
#define int long long

constexpr int sizik = 1000 * 1001;

template<typename T>
struct DrzewoPrzedzialoweSuma {
    T d[2 * sizik], neutral_element;
    int ll = 1;

    T op(const T& a, const T& b) { return a + b; }

    T na_przedziale(int o, int x, int y, int A, int B) {
        if (A <= x && y <= B) {
            return d[o];
        } else if (B < x || y < A) {
            return neutral_element;
        } else {
            return op(na_przedziale(o * 2, x, (x + y) / 2, A, B), na_przedziale(o * 2 + 1, (x + y) / 2 + 1, y, A, B));
        }
    }

    T na_przedziale(int A, int B) { return na_przedziale(1, 1, ll, A, B); }

    void akt(int v, const T& a) {
        v += this->ll - 1;
        d[v] = a;
        while (v > 1) {
            v /= 2;
            d[v] = op(d[2 * v], d[2 * v + 1]);
        }
    }

    DrzewoPrzedzialoweSuma(const std::vector<T>& init_arr, const T& nt_el) {
        this->neutral_element = nt_el;

        const int n = init_arr.size();

        while (ll <= n) {
            ll *= 2;
        }

        for (int i = 0; i <= 2 * ll; i++) {
            d[i] = this->neutral_element;
        }

        for (int i = 0; i < n; i++) {
            d[i + ll] = init_arr[i];
        }

        for (int i = ll - 1; i > 0; i--)
            d[i] = op(d[2 * i], d[2 * i + 1]);
    }
};

template<typename T>
struct DrzewoPrzedzialoweMini {
    T d[2 * sizik], neutral_element;
    int ll = 1;

    T op(const T& a, const T& b) { return std::min(a, b); }

    T na_przedziale(int o, int x, int y, int A, int B) {
        if (A <= x && y <= B) {
            return d[o];
        } else if (B < x || y < A) {
            return neutral_element;
        } else {
            return op(na_przedziale(o * 2, x, (x + y) / 2, A, B), na_przedziale(o * 2 + 1, (x + y) / 2 + 1, y, A, B));
        }
    }

    T na_przedziale(int A, int B) { return na_przedziale(1, 1, ll, A, B); }

    void akt(int v, const T& a) {
        v += this->ll - 1;
        d[v] = a;
        while (v > 1) {
            v /= 2;
            d[v] = op(d[2 * v], d[2 * v + 1]);
        }
    }

    DrzewoPrzedzialoweMini(const std::vector<T>& init_arr, const T& nt_el) {
        this->neutral_element = nt_el;

        const int n = init_arr.size();

        while (ll <= n) {
            ll *= 2;
        }

        for (int i = 0; i <= 2 * ll; i++) {
            d[i] = this->neutral_element;
        }

        for (int i = 0; i < n; i++) {
            d[i + ll] = init_arr[i];
        }

        for (int i = ll - 1; i > 0; i--)
            d[i] = op(d[2 * i], d[2 * i + 1]);
    }
};

int32_t main() {
    std::ios_base::sync_with_stdio(0);
    std::cin.tie(0);
    std::cout.tie(0);

    int n, cnt = 0;
    std::cin >> n;

    std::vector<std::pair<int, int>> v(n);
    for (auto& [a, b] : v) {
        std::cin >> a;
        b = cnt++;
    }

    int m;
    std::cin >> m;

    std::vector<std::array<int, 3>> f(m);

    for (auto& [a, b, p] : f) {
        std::cin >> a >> b >> p;
    }

    std::sort(f.begin(), f.end(), [](const auto& a, const auto& b) { return (a[1] - a[0] + 1) < (b[1] - b[0] + 1); });

    DrzewoPrzedzialoweMini d(v, {INT_MAX, INT_MAX});
    DrzewoPrzedzialoweSuma count(std::vector<int>(n), 0ll);

    int ans = 0;
    std::vector<int> vec_ans;

    for (auto& [a, b, p] : f) {
        int r = count.na_przedziale(a, b);
        p -= r;

        for (int i = 0; i < p; i++) {
            std::map<int, std::vector<int>> m;

            while (p > 0) {
                auto [l, j] = d.na_przedziale(a, b);

                d.akt(j + 1, {INT_MAX, INT_MAX});
                count.akt(j + 1, 1);
                vec_ans.push_back(j);

                p--;
                ans += l;
            }
        }
    }

    std::cout << ans << '\n';
    std::cout << vec_ans.size() << '\n';
    for (const auto& a : vec_ans) {
        std::cout << a + 1 << ' ';
    }
    std::cout << "\n";

    return 0;
}