// Slower C++ solution:
#include <bits/stdc++.h>



using namespace std;



const int inf = 0x3f3f3f3f;

const int maxv = 200010;

const int maxe = 100010;

int vertex, RailEdge, RoadEdge, cnt;

int RailHead[maxv], RoadHead[maxv], number[maxv], ans[maxv];

bool vis[maxv];

vector <int> v[maxv];

struct Edge

{

    int to, next;

}e[maxe * 4];



void addEdge(int *head, int from, int to)

{

    e[cnt].next = head[from];

    e[cnt].to = to;

    head[from] = cnt++;

}



void getNumberDFS(int cur)

{

    vis[cur] = true;

    number[cur] = cnt;

    for (int i = RoadHead[cur]; ~i; i = e[i].next)

    {

        int to = e[i].to;

        if (!vis[to])

            getNumberDFS(to);

    }

}



vector <int> valid;



void DFS(int cur)

{

    vis[cur] = true;

    int curNumber = number[cur];

    if (v[curNumber].size() == 0)

        valid.push_back(curNumber);

    v[curNumber].push_back(cur);

    for (int i = RailHead[cur]; ~i; i = e[i].next)

    {

        if (!vis[e[i].to])

            DFS(e[i].to);

    }

}



int main()

{

    memset(RailHead, -1, sizeof(RailHead));

    memset(RoadHead, -1, sizeof(RoadHead));

    for (int i = 0; i < maxv; i++)

        ans[i] = 1;





    int from, to;

    scanf("%d %d %d", &vertex, &RoadEdge, &RailEdge);

    for (int i = 0; i < RoadEdge; i++)

    {

        scanf("%d %d", &from, &to);

        addEdge(RoadHead, from, to);

        addEdge(RoadHead, to, from);

    }

    for (int i = 0; i < RailEdge; i++)

    {

        scanf("%d %d", &from, &to);

        addEdge(RailHead, from, to);

        addEdge(RailHead, to, from);

    }

    cnt = 0;

    for (int i = 1; i <= vertex; i++)

    {

        if (!vis[i])

        {

            getNumberDFS(i);

            cnt++;

        }

    }

//    printf("number:\n");

//    for (int i = 1; i <= vertex; i++)

//        printf("%d%c", number[i], i == vertex ? '\n' : ' ');

    memset(vis, false, sizeof(vis));

    for (int i = 1; i <= vertex; i++)

    {

        if (!vis[i])

        {

            DFS(i);

            for (int i = 0; i < valid.size(); i++)

            {

                int id = valid[i];

                for (int j = 0; j < v[id].size(); j++)

                    ans[v[id][j]] += v[id].size() - 1;

                v[id].clear();

            }

            valid.clear();

        }

    }

//    printf("answer:\n");

    for (int i = 1; i <= vertex; i++)

        printf("%d%c", ans[i], i == vertex ? '\n' : ' ');

    return 0;

}

/*

7 5 5

1 2

2 3

2 5

6 7

5 6

3 5

4 5

3 4

6 7

5 6

 

 1 1 4 1 4 4 4

 */






// Faster C++ solution for the same problem (measured speedup: 9.520635293037536x):
#include<cstdio>

#include<cstring>

#include<cctype>

#include<algorithm>

#define maxn 200005

using namespace std;



int n,k,l;

int info[maxn],Prev[maxn*2],to[maxn*2],cnt_e,col[2][maxn],c[maxn],siz[maxn],fa[maxn];

inline void Node(const int &u,const int &v){ Prev[++cnt_e]=info[u],info[u]=cnt_e,to[cnt_e]=v; }

void dfs(int now,int c,int typ)

{

    col[typ][now]=c;

    for(int i=info[now];i;i=Prev[i])

        if(!col[typ][to[i]])

            dfs(to[i],c,typ);

}

inline bool cmp(const int &a,const int &b){ return col[0][a]==col[0][b] ? col[1][a]<col[1][b] : col[0][a] < col[0][b]; }



int main()

{

    scanf("%d%d%d",&n,&k,&l);

    for(int i=1,u,v;i<=k;i++)

    {

        scanf("%d%d",&u,&v);

        Node(u,v),Node(v,u);

    }



    for(int i=1;i<=n;i++)

        if(!col[0][i])

            dfs(i,i,0);



    cnt_e=0;

    memset(info,0,sizeof info);

    for(int i=1,u,v;i<=l;i++)

    {

        scanf("%d%d",&u,&v);

        Node(u,v),Node(v,u);

    }





    for(int i=1;i<=n;i++)

        if(!col[1][i])

            dfs(i,i,1);





    for(int i=1;i<=n;i++)

        c[i]=i;



    sort(c+1,c+1+n,cmp);



    for(int i=1;i<=n;i++)

    {

        fa[c[i]]=c[i];

        if(i!=1 && col[0][c[i]] == col[0][c[i-1]] && col[1][c[i]]== col[1][c[i-1]])

            fa[c[i]] = fa[c[i-1]];

        siz[fa[c[i]]]++;

    }



    for(int i=1;i<n;i++) printf("%d ",siz[fa[i]]);

    printf("%d",siz[fa[n]]);

}