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 Java8 (OpenJDK 1.8.0) (judge verdict: Accepted)

//
import java.math.*;
import java.util.*;
import java.io.*;
  
public class Main { 
  
    static BufferedReader in;
    static PrintWriter out = new PrintWriter(System.out);
    static String file = "../in";
    static int test = 10; // 0 for local testing, 1 for std input
    static int inf = 1_000_000, mod = 1_000_000_007;

    void swap(int[]ary, int i, int j)
    {
        int t = ary[i];
        ary[i] = ary[j];
        ary[j] = t;
    }
    
    String[] split() throws Exception
    {
        return in.readLine().split(" ");
    }

    int readInt() throws Exception
    {
        return Integer.valueOf(in.readLine());
    }

    int[] toIntArray() throws Exception
    {
        String[] sp = split();
        int n = sp.length;
        int[] ary = new int[n];
        for(int i = 0; i < n; i++) ary[i] = Integer.valueOf(sp[i]);
        return ary;
    }

    String reverse(String str)
    {
        return new StringBuilder(str).reverse().toString();
    }


    long pow(long a, int pow)
    {
        long res = 1;
        while(pow > 0)
        {
            if(pow % 2 != 0) {
                res *= a;
                res %= mod;
            }
            a = a * a;
            a %= mod;
            pow /= 2;
        }

        return res;
    }

    public static void main(String[] args) throws Exception
    {
        int _k = Integer.valueOf("1");
        if(test > 0) in = new BufferedReader(new InputStreamReader(System.in));
        else in = new BufferedReader(new FileReader(file));
        if(test < 0) {String[] str = in.readLine().split(" ");}
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/
/***********************************************************************/
        // System.out.println((-100 + 0) / 2);

        new Main().d();
        out.flush();
    }

    void d() throws Exception{
        int[] ary = toIntArray();
        int n = ary[0], m = ary[1], k = ary[2];
        int[] f = new int[n];
        int[] friends = new int[n];
        int[] cand = new int[n];

        for(int i = 0; i < n; i++) f[i] = i;
        while(m-- > 0)
        {
            ary = toIntArray();
            int a = ary[0] - 1, b = ary[1] - 1;
            friends[a]++;
            friends[b]++;
            a = find(f, a);
            b = find(f, b);
            // if(a != b) 
            f[a] = b;
            // System.out.println(Arrays.toString(f));
        }
        // block
        
        Map<Integer, Integer> map = new HashMap<>();
        
        for(int i = 0; i < n; i++)
        {
            int p = find(f, i);
            map.put(p, map.getOrDefault(p, 0) + 1);
        }

        for(int i = 0; i < n; i++)
        {
            int p = find(f, i);
            cand[i] = map.get(p) - 1;
        }

        // System.out.println(Arrays.toString(cand));

        while(k-- > 0)
        {
            ary = toIntArray();
            int a = ary[0] - 1, b = ary[1] - 1;
            int pa = find(f, a);
            int pb = find(f, b);
            if(pa == pb)
            {
                cand[a]--;
                cand[b]--;
            }
        }

        // System.out.println(Arrays.toString(friends));
        
        // System.out.println(map);       

        for(int i = 0; i < n; i++)
        {
            cand[i] -= friends[i];
        }

        for(int c : cand) out.printf("%d ", c);

    }

    int find(int[] f, int p)
    {
        int fp = f[p];
        while(fp != f[fp]) fp = f[f[fp]];
        return f[p] = fp;
    }

    void c() throws Exception
    {
        int[] ary = toIntArray();
        int n = ary[0], m = ary[1];

        int[] digits = new int[n];
        Arrays.fill(digits, -1);
        int[] vis = new int[n];
        while(m-- > 0)
        {
            ary = toIntArray();
            int s = ary[0] - 1, c = ary[1];
            if(digits[s] > 0 && digits[s] != c)
            {
                out.println(-1);
                return;
            }
            // vis[s]++;
            digits[s] = c;
        }
        if(digits[0] == 0 && n > 1)
        {
            out.println(-1);
            return;
        }
        for(int i = 0; i < n; i++)
        {
            if(digits[i] < 0) digits[i] = 0;
        }
        if(digits[0] == 0 && n > 1) digits[0] = 1;
        for(int k : digits) out.printf("%d", k);

    }
    void b() throws Exception
    {
        int[][] g = new int[3][];
        for(int i = 0; i < 3; i++)
        {
            g[i] = toIntArray();
        }
        int n = readInt();
        boolean[][] v = new boolean[3][3];
        while(n-- > 0)
        {
            int b = readInt();
            for(int i = 0; i < 3; i++)
            {
                for(int j = 0; j < 3; j++)
                {
                    if(g[i][j] == b) v[i][j] = true;
                }
            }
        }

        boolean ans = false;
        for(int i = 0; i < 3; i++)
        {
            boolean col = true;
            for(int j = 0; j < 3; j++)
            {
                col &= v[i][j];
            }
            if(col) ans = true;

            boolean row = true;
            for(int j = 0; j < 3; j++)
            {
                row &= v[j][i];
            }
            if(row) ans = true;
        }

        if(v[0][0] && v[1][1] && v[2][2]) ans = true;
        if(v[0][2] && v[1][1] && v[2][0]) ans = true;
        if(ans) out.println("Yes");
        else out.println("No");
    }
    void a() throws Exception
    {
        int n = readInt();
        
        out.println((n + 1) / 2);
    }
}