#include <bits/stdc++.h>

using i64 = long long;
template<class T>
struct MinCostFlow {
    struct _Edge {
        int to;
        T cap;
        T cost;
        _Edge(int to_, T cap_, T cost_) : to(to_), cap(cap_), cost(cost_) {}
    };
    int n;
    std::vector<_Edge> e;
    std::vector<std::vector<int>> g;
    std::vector<T> h, dis;
    std::vector<int> pre;
    bool dijkstra(int s, int t) {
        dis.assign(n, std::numeric_limits<T>::max());
        pre.assign(n, -1);
        std::priority_queue<std::pair<T, int>, std::vector<std::pair<T, int>>, std::greater<std::pair<T, int>>> que;
        dis[s] = 0;
        que.emplace(0, s);
        while (!que.empty()) {
            T d = que.top().first;
            int u = que.top().second;
            que.pop();
            if (dis[u] != d) {
                continue;
            }
            for (int i : g[u]) {
                int v = e[i].to;
                T cap = e[i].cap;
                T cost = e[i].cost;
                if (cap > 0 && dis[v] > d + h[u] - h[v] + cost) {
                    dis[v] = d + h[u] - h[v] + cost;
                    pre[v] = i;
                    que.emplace(dis[v], v);
                }
            }
        }
        return dis[t] != std::numeric_limits<T>::max();
    }
    MinCostFlow() {}
    MinCostFlow(int n_) {
        init(n_);
    }
    void init(int n_) {
        n = n_;
        e.clear();
        g.assign(n, {});
    }
    void addEdge(int u, int v, T cap, T cost) {
        g[u].push_back(e.size());
        e.emplace_back(v, cap, cost);
        g[v].push_back(e.size());
        e.emplace_back(u, 0, -cost);
    }
    std::pair<T, T> flow(int s, int t) {
        T flow = 0;
        T cost = 0;
        h.assign(n, 0);
        while (dijkstra(s, t)) {
            for (int i = 0; i < n; ++i) {
                h[i] += dis[i];
            }
            T aug = std::numeric_limits<int>::max();
            for (int i = t; i != s; i = e[pre[i] ^ 1].to) {
                aug = std::min(aug, e[pre[i]].cap);
            }
            for (int i = t; i != s; i = e[pre[i] ^ 1].to) {
                e[pre[i]].cap -= aug;
                e[pre[i] ^ 1].cap += aug;
            }
            flow += aug;
            cost += aug * h[t];
        }
        return std::make_pair(flow, cost);
    }
    struct Edge {
        int from;
        int to;
        T cap;
        T cost;
        T flow;
    };
    std::vector<Edge> edges() {
        std::vector<Edge> a;
        for (int i = 0; i < e.size(); i += 2) {
            Edge x;
            x.from = e[i + 1].to;
            x.to = e[i].to;
            x.cap = e[i].cap + e[i + 1].cap;
            x.cost = e[i].cost;
            x.flow = e[i + 1].cap;
            a.push_back(x);
        }
        return a;
    }
};

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int n, m;
    std::cin >> n >> m;
    
    std::map<std::pair<int, int>, std::vector<int>> e2f;
    std::vector<std::vector<int>> v2f(n);
    std::vector<int> deg(n);
    for (int i = 0; i < m; i++) {
        int k;
        std::cin >> k;
        std::vector<int> a(k);
        for (int j = 0; j < k; j++) {
            std::cin >> a[j];
            a[j]--;
        }
        for (int j = 0; j < k; j++) {
            e2f[std::minmax(a[j], a[(j + 1) % k])].push_back(i);
            v2f[a[j]].push_back(i);
        }
    }
    for (auto [e, fs] : e2f) {
        auto [u, v] = e;
        deg[u] += 1;
        deg[v] += 1;
    }
    
    MinCostFlow<int> g(n + m + 3);
    int S = n + m + 1, T = S + 1;
    for (int v = 0; v < n; v++) {
        if (deg[v] > v2f[v].size()) {
            v2f[v].push_back(m);
        }
    }
    
    constexpr int inf = 1E9;
    
    for (int v = 0; v < n; v++) {
        if (deg[v] == 2) {
            g.addEdge(n + v2f[v][0], n + v2f[v][1], 1, 0);
            g.addEdge(n + v2f[v][1], n + v2f[v][0], 1, 0);
        } else if (deg[v] == 3) {
            g.addEdge(S, v, 2, 0);
            for (auto f : v2f[v]) {
                g.addEdge(v, n + f, 1, 0);
            }
        } else {
            g.addEdge(S, v, 4, 0);
            for (auto f : v2f[v]) {
                g.addEdge(v, n + f, 1, 0);
            }
        }
    }
    for (auto [e, fs] : e2f) {
        if (fs.size() == 1) {
            fs.push_back(m);
        }
        g.addEdge(n + fs[0], n + fs[1], inf, 1);
        g.addEdge(n + fs[1], n + fs[0], inf, 1);
    }
    g.addEdge(T, S, inf, 0);
    for (int f = 0; f < m; f++) {
        g.addEdge(n + f, T, 4, 0);
    }
    g.addEdge(S, n + m, 4, 0);
    int ans = g.flow(S, T).second;
    std::cout << ans << "\n";
    
    return 0;
}