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

#define fr            first
#define sc            second
#define pb            push_back
#define mp            make_pair
#define mt            make_tuple
#define pii           pair<int, int>
#define tiii          tuple<long, long, long>
#define all(s)        (s).begin(), (s).end()
#define lowbit(x)     ((x) & -(x))
#define rep(i, x, y)  for (int (i) = (x); (i) <= (y); ++(i))
#define per(i, x, y)  for (int (i) = (x); (i) >= (y); --(i))

inline bool getmin(int &a, int b) {return (a > b ? (a = b, true) : false);}
inline bool getmax(int &a, int b) {return (a < b ? (a = b, true) : false);}

const int N   = 110007;
const int inf = 1000000000;

namespace Hopcroft_Karp {

    bool vis[N];
    vector<int> e[N];
    int nl, nr, ml[N], mr[N], dl[N], dr[N]; // m for match, d for distance
    
    inline bool bfs() {
        static int q[N], hd, tl; hd = 1; tl = 0;
        memset(dl, -1, sizeof(int) * (nl + 1));
        memset(dr, -1, sizeof(int) * (nr + 1));
        for (int i = 1; i <= nl; ++i) if (!ml[i]) {dl[i] = 0; q[++tl] = i;}
        int dT = inf;
        while (hd <= tl) {
            int u = q[hd++];
            if (dl[u] >= dT) break;
            for (auto v : e[u])
                if (dr[v] == -1) {
                    dr[v] = dl[u] + 1;
                    if (!mr[v]) getmin(dT, dr[v] + 1);
                    else {dl[mr[v]] = dr[v] + 1; q[++tl] = mr[v];}
                }
        }
        return dT != inf;
    }

    bool dfs(int u) {
        for (auto v : e[u]) {
            if (vis[v] || dl[u] + 1 != dr[v]) continue;
            vis[v] = true;
            if (!mr[v] || dfs(mr[v])) {mr[v] = u; ml[u] = v; return true;}
        }
        return false;
    }

    inline void add(int u, int v) {e[u].push_back(v);}

    inline int max_matching() {
        int ans = 0;
        while(bfs()) {
            memset(vis, 0, sizeof(bool) * (nr + 1));
            for (int i = 1; i <= nl; ++i) if (!ml[i]) ans += dfs(i);
        }
        return ans;
    }
}

int tot, cnts;

bool vis[N];

unordered_map<string, int> tr;

map<vector<int>, int> id;

int main() {
    int n; cin >> n;
    for (int i = 1; i <= n; ++i) { 
        int k; cin >> k;
        vector<int> course(k);
        for (int j = 0; j < k; ++j) {
            string str;
            cin >> str;
            if (!tr[str]) tr[str] = ++cnts;
            course[j] = tr[str];
        }
        sort(all(course));
        vector<int> subset(1 << k);
        for (int S = 1; S < (1 << k); ++S) {
            vector<int> tmp(__builtin_popcount(S));
            for (int j = 0, tmpcnt = 0; j < k; ++j)
                if (S & (1 << j)) tmp[tmpcnt++] = course[j];
            if (!id[tmp]) id[tmp] = ++tot;
            subset[S] = id[tmp];
        }
        for (int S = 1; S < (1 << k); ++S) {
            int nwid = subset[S];
            if (vis[nwid]) continue;
            vis[nwid] = true;
            for (int s = (S & (S - 1)); s; s = (S & (s - 1))) Hopcroft_Karp::add(nwid, subset[s]);
        }  
    }
    Hopcroft_Karp::nl = Hopcroft_Karp::nr = tot;
    printf("%d\n", tot - Hopcroft_Karp::max_matching());
    return 0;
}