#include <bits/stdc++.h>
using namespace std;

using i64 = long long;

template <typename T>
struct Fenwick {
    int n;
    vector<T> a;
    Fenwick(int n = 0) : n(n), a(n) {}
    void add(int p, T v) {
        while (p < n) {
            a[p] += v;
            p |= p + 1;
        }
    }
    T sum(int p) {
        T res = {};
        while (p >= 0) {
            res += a[p];
            p = (p & p + 1) - 1;
        }
        return res;
    }
};

i64 countInversion(const vector<int> &a) {
    int n = a.size();
    Fenwick<int> f(n);
    vector<int> ord(n);
    iota(ord.begin(), ord.end(), 0);
    sort(ord.begin(), ord.end(), [&](auto i, auto j) {
        return pair(a[i], -i) < pair(a[j], -j);
    });

    i64 res = 0;
    for (auto i : ord) {
        res += f.sum(n - 1) - f.sum(i);
        f.add(i, 1);
    }

    return res;
}

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);

    auto solve = [&]() {
        int n, q;
        cin >> n >> q;

        vector<int> a(n);
        for (int i = 0; i < n; i++) {
            cin >> a[i];
        }

        auto s = a;
        sort(s.begin(), s.end());

        i64 base = countInversion(a);

        while (q--) {
            int m;
            cin >> m;

            vector<int> b(m);
            for (int i = 0; i < m; i++) {
                cin >> b[i];
            }

            i64 res = 0;
            for (int i = 0; i < m; i++) {
                res += n - (upper_bound(s.begin(), s.end(), b[i]) - s.begin());
            }

            i64 cur = res;
            for (int i = 0; i < m; i++) {
                cur -= n - (upper_bound(s.begin(), s.end(), b[i]) - s.begin());
                cur += lower_bound(s.begin(), s.end(), b[i]) - s.begin();
                res = min(res, cur);
            }

            res += base + countInversion(b);
            cout << res << '\n';
        }
    };
    
    solve();
    
    return 0;
}