CSU 1837

#include <set>
#include <map>
#include <list>
#include <cmath>
#include <queue>
#include <stack>
#include <vector>
#include <bitset>
#include <string>
#include <cctype>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <sstream>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ull, ull> puu;

#define inf (0x3f3f3f3f)
#define lnf (0x3f3f3f3f3f3f3f3f)
#define eps (1e-9)
#define fi first
#define se second

bool sgn(double a, string select, double b) {
    if(select == "==")return fabs(a - b) < eps;
    if(select == "!=")return fabs(a - b) > eps;
    if(select == "<")return a - b < -eps;
    if(select == "<=")return a - b < eps;
    if(select == ">")return a - b > eps;
    if(select == ">=")return a - b > -eps;
}


//--------------------------

const ll mod = 1000000007;
const int maxn = 100010;

const int PA = 11111;
const int PB = 31111;

int head[maxn];
int son[maxn];
int val[maxn];
ull h[maxn];
int ans;
int cnt, n;
int num;
pii root;
int rt_min;
map<puu, int> tree;



struct Edge {
    int to;
    int next;
};

Edge edge[2 * maxn];

void init() {
    cnt = 0;
    num = 1;
    rt_min = inf;
    memset(head, -1, sizeof(head));
}

void add_edge(int u, int v) {
    edge[cnt].to = v;
    edge[cnt].next = head[u];
    head[u] = cnt++;
}


void getroot(int u, int par) {
    son[u] = 1;
    int Max = 0;
    for(int i = head[u]; ~i; i = edge[i].next) {
        int v = edge[i].to;
        if(v == par) continue;
        getroot(v, u);
        son[u] += son[v];
        Max = max(Max, son[v]);
    }
    Max = max(Max, num - son[u]);
    if(Max < rt_min) {
        rt_min = Max;
        root.fi = u;
        root.se = u;
    } else if(Max == rt_min) {
        root.se = u;
    }
}

ull gethash(int u, int par) {
    if(par == -1) h[u] = PA;
    else h[u] = ((ull)(val[u] - val[par]))^PA;

    for(int i = head[u]; ~i; i = edge[i].next) {
        int v = edge[i].to;
        if(v == par)continue;
        gethash(v, u);
        h[u] *= h[v] ^ PB;
    }
    return h[u];
}

string str;

void solve() {
    cin >> n;
    int u, v;
    cin.get();
    for(int i = 0; i < n; i++) {
        init();
        char en;
        getline(cin,str);
        stringstream in(str);
        int u,v;
        while(in>>u>>v) {
            add_edge(u, v);
            add_edge(v, u);
            num++;
        }
        for(int j = 1; j <= num; j++) {
            cin>>val[j];
        }
        cin.get();
        getroot(1, -1);
        ull a, b;
        puu now;
        now.fi =  gethash(root.fi, -1);
        if(root.fi != root.se) {
            now.se = gethash(root.se, -1);
        }
        if(now.fi>now.se)swap(now.fi,now.se);
        tree[now]++;

    }
    vector<int> ans;
    for(auto it = tree.begin(); it != tree.end(); it++) {
        ans.push_back(it->se);
    }
    sort(ans.begin(), ans.end());
    for(int i = 0; i < ans.size() - 1; i++) {
        printf("%d ", ans[i] );
    }
    printf("%d\n", ans[ans.size() - 1] );



}

int main() {

#ifndef ONLINE_JUDGE
    freopen("1.in", "r", stdin);
//    freopen("1.out", "w", stdout);
#endif
    iostream::sync_with_stdio(false);
    solve();
    return 0;
}

/**********************************************************************
    Problem: 1837
    User: tankwoks
    Language: C++
    Result: RE
**********************************************************************/

/**********************************************************************
    Problem: 1837
    User: tankwoks
    Language: C++
    Result: AC
    Time:108 ms
    Memory:6832 kb
**********************************************************************/