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

template <class T> struct csr {
    using itr = typename std::vector<T>::iterator;
    struct Node {
        itr st, en;
        itr begin() { return st; }
        itr end() { return en; }
        int size() { return en - st; }
        T operator[](int p){ return st[p]; }
    };
    const int N;
    std::vector<int> start;
    std::vector<T> E;
    std::vector<std::pair<int,T>> edge;
    csr(int n) : N(n), start(n + 1) {}
    void add_edge(int u, T v){
        assert(0 <= u && u < N);
        start[u + 1]++;
        edge.emplace_back(u, v);
    }
    void build(){
        E.resize(edge.size());
        for(int i = 0; i < N; i++) start[i + 1] += start[i];
        auto cnt = start;
        for(auto [u, v] : edge) E[cnt[u]++] = v;
    }
    Node operator[](int p) {
        return Node{E.begin() + start[p], E.begin() + start[p + 1]};
    }
};

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin >> n;
    csr<int> g(n);
    vector<int> deg(n), E(n);
    for(int v = 0; v < n; v++){
        cin >> deg[v];
        for(int j = 0, u; j < deg[v]; j++){
            cin >> u;
            g.add_edge(v, u);
            E[u] ^= v;
        }
    }
    g.build();
    int th = 0, up = 0;
    vector<bool> vis(n);
    vector<int> ans(n), cnt(n + 1);
    vector<array<int,2>> dp(n);
    auto dfs = [&](auto dfs, int v, int p) -> void {
        if(deg[v] == th){
            vis[v] = true;
            cnt[th]++;
            dp[v] = {0, 1};
            for(auto u : g[v]){
                u = E[u] ^ v;
                if(u == p) continue;
                if(deg[u] < th) continue;
                dfs(dfs, u, v);
                dp[v][0] += dp[u][1];
                dp[v][1] += dp[u][0];
            }
            dp[v][1] = max(dp[v][1], dp[v][0]);
            return;
        }
        up++;
        // deg[v] - th - 1個までなら0コスト
        // deg[v] - th個なら1コスト
        vector<array<int,2>> tmp;
        for(auto u : g[v]){
            u = E[u] ^ v;
            if(u == p) continue;
            if(deg[u] < th) continue;
            dfs(dfs, u, v);
            tmp.emplace_back(dp[u]);
        }
        sort(tmp.begin(), tmp.end(), [&](auto a, auto b){
            return a[1] - a[0] > b[1] - b[0];
        });
        int c = tmp.size();
        vector<int> sv0(c + 1), sv1(c + 1);
        for(int i = 0; i < c; i++){
            sv0[i + 1] = sv0[i] + tmp[i][0];
            sv1[i + 1] = sv1[i] + tmp[i][1];
        }
        dp[v][0] = sv1[c];
        if(c >= deg[v] - th - 1){
            dp[v][0] = max(dp[v][0], sv1[deg[v] - th - 1] + (sv0[c] - sv0[deg[v] - th - 1]) + 1);
        }else{
            dp[v][0] = max(dp[v][0], sv1[c] + 1);
        }
        dp[v][1] = sv0[c] + 1;
        if(c >= deg[v] - th){
            dp[v][1] = max(dp[v][1], sv1[deg[v] - th] + (sv0[c] - sv0[deg[v] - th]) + 1);
        }else{
            dp[v][1] = max(dp[v][1], sv1[c] + 1);
        }
        dp[v][1] = max(dp[v][1], dp[v][0]);
    };
    for(int v = 0; v < n; v++){
        if(vis[v])continue;
        th = deg[v];
        up = 0;
        dfs(dfs, v, -1);
        ans[deg[v]] += dp[v][1] - up;
    }
    for(int i = n - 1; i >= 0; i--) cnt[i] += cnt[i + 1];
    for(int i = 1; i < n; i++) cout << ans[i] + cnt[i + 1] << (i + 1 == n ? '\n' : ' ');
}