Problem:
Score : 400 points

Problem Statement

An SNS has N users - User 1, User 2, \cdots, User N.

Between these N users, there are some relationships - M friendships and K blockships.

For each i = 1, 2, \cdots, M, there is a bidirectional friendship between User A_i and User B_i.

For each i = 1, 2, \cdots, K, there is a bidirectional blockship between User C_i and User D_i.

We define User a to be a friend candidate for User b when all of the following four conditions are satisfied:

a \neq b.

There is not a friendship between User a and User b.

There is not a blockship between User a and User b.

There exists a sequence c_0, c_1, c_2, \cdots, c_L consisting of integers between 1 and N (inclusive) such that c_0 = a, c_L = b, and there is a friendship between User c_i and c_{i+1} for each i = 0, 1, \cdots, L - 1.

For each user i = 1, 2, ... N, how many friend candidates does it have?

Constraints

All values in input are integers.

2 ≤ N ≤ 10^5

0 \leq M \leq 10^5

0 \leq K \leq 10^5

1 \leq A_i, B_i \leq N

A_i \neq B_i

1 \leq C_i, D_i \leq N

C_i \neq D_i

(A_i, B_i) \neq (A_j, B_j) (i \neq j)

(A_i, B_i) \neq (B_j, A_j)

(C_i, D_i) \neq (C_j, D_j) (i \neq j)

(C_i, D_i) \neq (D_j, C_j)

(A_i, B_i) \neq (C_j, D_j)

(A_i, B_i) \neq (D_j, C_j)

Input

Input is given from Standard Input in the following format:

N M K
A_1 B_1
\vdots
A_M B_M
C_1 D_1
\vdots
C_K D_K

Output

Print the answers in order, with space in between.

Sample Input 1

4 4 1
2 1
1 3
3 2
3 4
4 1

Sample Output 1

0 1 0 1

There is a friendship between User 2 and 3, and between 3 and 4. Also, there is no friendship or blockship between User 2 and 4. Thus, User 4 is a friend candidate for User 2.

However, neither User 1 or 3 is a friend candidate for User 2, so User 2 has one friend candidate.

Sample Input 2

5 10 0
1 2
1 3
1 4
1 5
3 2
2 4
2 5
4 3
5 3
4 5

Sample Output 2

0 0 0 0 0

Everyone is a friend of everyone else and has no friend candidate.

Sample Input 3

10 9 3
10 1
6 7
8 2
2 5
8 4
7 3
10 9
6 4
5 8
2 6
7 5
3 1

Sample Output 3

1 3 5 4 3 3 3 3 1 0

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include<iostream>
#include<string>
#include<algorithm>    
#include<cmath>
#include<map>
#include<vector>
#include<math.h>
#include<stdio.h>
#include<stack>
#include<queue>
#include<tuple>
#include<cassert>
#include<set>
//#include<bits/stdc++.h>
#define int long long
using namespace std;
const int INF = 1000000000000;
const int mod = 1000000007;
int par1[213456], par2[213456], size1[345678];//親
int depth1[213456], depth2[213456];//木の深さ
//n要素で初期化
void init1(int n) {
	for (int i = 0; i <= n; i++) { par1[i] = i; size1[i] = 1; depth1[i] = 0; }
}
void init2(int n) {
	for (int i = 0; i <= n; i++) { par2[i] = i; depth2[i] = 0; }
}
//木の根を求める
int find1(int x) {
	if (par1[x] == x) { return x; }
	else { return par1[x] = find1(par1[x]); }
}
int find2(int x) {
	if (par2[x] == x) { return x; }
	else { return par2[x] = find2(par2[x]); }
}
//xとyの属する集合を併合
void unite1(int x, int y) {
	x = find1(x); y = find1(y);
	if (x == y) { return; }
	if (depth1[x] < depth1[y]) { par1[x] = y; size1[y] += size1[x]; }
	else { par1[y] = x; size1[x] += size1[y]; if (depth1[x] == depth1[y])depth1[x]++; }
}
void unite2(int x, int y) {
	x = find2(x); y = find2(y);
	if (x == y) { return; }
	if (depth2[x] < depth2[y]) { par2[x] = y; }
	else { par2[y] = x; if (depth2[x] == depth2[y])depth2[x]++; }
}
//xとyが同じ集合に属するか否か
bool same1(int x, int y) {
	return find1(x) == find1(y);
}
bool same2(int x, int y) {
	return find2(x) == find2(y);
}
int tomodati[345678];
signed main() {
	int n, k, l, a, b, c, d; cin >> n >> k >> l;
	vector<vector<int>>test(n + 1, vector<int>(2));
	map<int, map<int, int> > ok;
	init1(n + 1); init2(n + 1);
	for (int h = 0; h < k; h++) {
		cin >> a >> b; if (a > b) { swap(a, b); } unite1(a, b);
		tomodati[a]++; tomodati[b]++;
	}
	for (int h = 1; h <= n; h++) {
		test[h][0] = find1(h);
	}
	for (int h = 0; h < l; h++) {
		cin >> c >> d; if (c > d) { swap(c, d); } unite2(c, d);
	}
	for (int h = 1; h <= n; h++) {
		test[h][1] = find2(h);
	}
	for (int h = 1; h <= n; h++) {
		ok[test[h][0]][test[h][1]]++;
	}
	for (int h = 1; h <= n; h++) {
		int ans = size1[par1[h]] - ok[test[h][0]][test[h][1]] - tomodati[h];
		if (h == 1) { cout << ans; }
		else { cout << ' ' << ans; }
	}
	cout << endl;
	return 0;
}