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

class SegmentTree {
    using F = function<pair<vector<int>, vector<int>>(pair<vector<int>, vector<int>>, pair<vector<int>, vector<int>>)>;
    int n, le;
    vector<pair<vector<int>, vector<int>>> seg;
    F func;
    pair<vector<int>, vector<int>> identity;

public:
    SegmentTree(int n, F func, pair<vector<int>, vector<int>> identity)
        : n(n), func(func), identity(identity) {
        le = 1;
        while (le < n) le *= 2;
        seg.assign(2 * le, identity);
    }

    void set(int i, pair<vector<int>, vector<int>> x) {
        i += le;
        seg[i] = x;
        while (i > 1) {
            i /= 2;
            seg[i] = func(seg[i * 2], seg[i * 2 + 1]);
        }
    }

    pair<vector<int>, vector<int>> fold(int l, int r) {
        pair<vector<int>, vector<int>> vl = identity, vr = identity;
        l += le; r += le;
        while (l < r) {
            if (l & 1) vl = func(vl, seg[l++]);
            if (r & 1) vr = func(seg[--r], vr);
            l /= 2; r /= 2;
        }
        return func(vl, vr);
    }
};

pair<unordered_map<int, int>, vector<int>> compress(const vector<int>& lst) {
    vector<int> sorted_lst = lst;
    sort(sorted_lst.begin(), sorted_lst.end());
    sorted_lst.erase(unique(sorted_lst.begin(), sorted_lst.end()), sorted_lst.end());

    unordered_map<int, int> comp;
    for (int i = 0; i < (int)sorted_lst.size(); ++i) {
        comp[sorted_lst[i]] = i;
    }
    return {comp, sorted_lst};
}

int main() {
    int N;
    cin >> N;
    vector<vector<int>> A(N);
    for (int i = 0; i < N; ++i) {
        int k;
        cin >> k;
        A[i].resize(k);
        for (int j = 0; j < k; ++j) {
            cin >> A[i][j];
        }
    }

    vector<int> all_values;
    for (const auto& vec : A) {
        all_values.insert(all_values.end(), vec.begin(), vec.end());
    }

    auto [comp, decomp] = compress(all_values);
    vector<int> L(N), R(N);
    for (int i = 0; i < N; ++i) {
        for (int& x : A[i]) {
            x = comp[x];
        }
        sort(A[i].begin(), A[i].end());
        L[i] = A[i].front();
        R[i] = A[i].back() + 1;
    }

    int le = comp.size();
    vector<vector<int>> query0(le + 1);
    vector<vector<pair<int,int>>> query1(le + 1);
    for (int i = 0; i < N; ++i) {
        query0[R[i]].push_back(L[i]);
        query1[L[i] + 1].emplace_back(R[i], i);
    }

    const int INF = INT_MAX;
    auto func = [](pair<vector<int>, vector<int>> a, pair<vector<int>, vector<int>> b) {
        vector<int> mi = a.first, ma = a.second;
        mi.insert(mi.end(), b.first.begin(), b.first.end());
        ma.insert(ma.end(), b.second.begin(), b.second.end());
        sort(mi.begin(), mi.end());
        sort(ma.rbegin(), ma.rend());
        mi.resize(min(2, (int)mi.size()));
        ma.resize(min(2, (int)ma.size()));
        return make_pair(mi, ma);
    };
    pair<vector<int>, vector<int>> identity = {{}, {}};
    SegmentTree st(le + 1, func, identity);

    vector<int> maxL(N, -INF), minR(N, INF);
    for (int r = le; r >= 0; --r) {
        for (int l : query0[r]) {
            st.set(l, func(st.fold(l, l + 1), {{r}, {l}}));
        }
        for (auto [b, i] : query1[r]) {
            auto [mi, ma] = st.fold(0, b);
            if (mi.size() > 1) {
                minR[i] = mi[0] == R[i] ? mi[1] : mi[0];
            }
            if (ma.size() > 1) {
                maxL[i] = ma[0] == L[i] ? ma[1] : ma[0];
            }
        }
    }

    vector<bool> one(N, false);
    for (int i = 0; i < N; ++i) {
        for (int x : A[i]) {
            if (maxL[i] < x && x < minR[i] - 1) {
                one[i] = true;
            }
        }
    }

    vector<int> idx(N);
    iota(idx.begin(), idx.end(), 0);
    sort(idx.begin(), idx.end(), [&](int i, int j) {
        return R[i] < R[j];
    });

    int cur = 0, cnt = 0;
    for (int i : idx) {
        if (one[i] && cur <= L[i]) {
            cur = R[i];
            cnt++;
        }
    }

    int ans = cnt + (N - cnt) * 2;
    cout << ans << "\n";
    return 0;
}