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)

    ////////////////////////////////////////////////////
    //                                                //
    //  For her who keeps the fire kindling in me...  //
    //                                                //
    ////////////////////////////////////////////////////


    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileOutputStream;
    import java.io.IOException; 
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.OutputStreamWriter;
    import java.io.PrintWriter;
    // import java.util.Scanner;
    // import java.util.Arrays;
    // import java.util.ArrayList;
    // import java.util.Collections; 
    // import java.util.StringTokenizer;
    import java.util.*;
    import java.lang.Math;
    import java.awt.Point;                            
    
    import java.awt.geom.*;
    
    public class Main{
    
        // static class Pair{
        //     int x;
        //     int y;
        // }

        static class DisjointUnionSets { 
            int[] rank, parent, ele_count; 
            int n; 
          
            // Constructor 
            public DisjointUnionSets(int n) 
            { 
                rank = new int[n]; 
                parent = new int[n];
                ele_count = new int[n];
                this.n = n; 
                makeSet(); 
            } 
          
            // Creates n sets with single item in each 
            void makeSet() 
            { 
                for (int i = 0; i < n; i++) { 
                    // Initially, all elements are in 
                    // their own set. 
                    parent[i] = i; 
                    ele_count[i] = 1;
                } 
            } 
          
            // Returns representative of x's set 
            int find(int x) 
            { 
                // Finds the representative of the set 
                // that x is an element of 
                if (parent[x] != x) { 
                    // if x is not the parent of itself 
                    // Then x is not the representative of 
                    // his set,

                    parent[x] = find(parent[x]); 
                    
                    // so we recursively call Find on its parent 
                    // and move i's node directly under the 
                    // representative of this set 
                } 
          
                return parent[x]; 
            }



            int setSize(int x){
                int par = find(x);
                return ele_count[par];
            }
          


            // Unites the set that includes x and the set 
            // that includes x 
            void union(int x, int y) 
            { 
                // Find representatives of two sets 
                int xRoot = find(x), yRoot = find(y); 
          
                // Elements are in the same set, no need 
                // to unite anything. 
                if (xRoot == yRoot) 
                    return; 
          
                // If x's rank is less than y's rank 
                if (rank[xRoot] < rank[yRoot]){ 
          
                    // Then move x under y  so that depth 
                    // of tree remains less 
                    parent[xRoot] = yRoot;
                
                    ele_count[yRoot] = ele_count[yRoot] + ele_count[xRoot];
          
                // Else if y's rank is less than x's rank 
                }else if (rank[yRoot] < rank[xRoot]) {
          
                    // Then move y under x so that depth of 
                    // tree remains less 
                    parent[yRoot] = xRoot; 
                    ele_count[xRoot] = ele_count[yRoot] + ele_count[xRoot];
                
                } else // if ranks are the same 
                { 
                    // Then move y under x (doesn't matter 
                    // which one goes where) 
                    parent[yRoot] = xRoot; 
          
                    ele_count[xRoot] = ele_count[yRoot] + ele_count[xRoot];

                    // And increment the result tree's 
                    // rank by 1 
                    rank[xRoot] = rank[xRoot] + 1; 
                } 
            } 
        } 

        public static void main(String args[]){
            try{
                FastReader s = new FastReader();
                BufferedWriter w = new BufferedWriter(new OutputStreamWriter(System.out));
                int i, j, k, x, y, t, n, m, count, key, size, Pairer, minglob, minloc, beg, end, begl, endr, ld, up, down, maxele, minele;
                long ans, sqrt, q, r, sum, maxup, maxdown, X, Y, Q, MOD;//, sum2;
                boolean flag, flag2;
    
                double avg;
    
                // t = s.nextInt();
    
                // for(; t>0; t--){
    
                    //n = s.nextInt();
                    //Y = s.nextLong();
    
                    n = s.nextInt();
                    m = s.nextInt();
                    k = s.nextInt();
    

                    DisjointUnionSets dsu = new DisjointUnionSets(n);

                    ArrayList<Integer> frnd_lst[] = new ArrayList[n];
                    ArrayList<Integer> block_lst[] = new ArrayList[n];


                    for(i=0; i<n; i++)
                        frnd_lst[i] = new ArrayList<Integer>();
                    
                    for(i=0; i<m; i++){
                        x = s.nextInt();
                        y = s.nextInt();

                        x--;    y--;
                        //if(frnd_lst[x].size() == 0)
                            frnd_lst[x].add(y);
                            frnd_lst[y].add(x);

                        dsu.union(x, y);
                        
                    }
    

                    for(i=0; i<n; i++)
                        block_lst[i] = new ArrayList<Integer>();
                    
                    for(i=0; i<k; i++){
                        x = s.nextInt();
                        y = s.nextInt();

                        x--;    y--;
                        //if(frnd_lst[x].size() == 0)
                            block_lst[x].add(y);
                            block_lst[y].add(x);
                        
                    }
    

                    ArrayList<Integer> fl, bl;
                    for(i=0; i<n; i++){
                        size = dsu.setSize(i);

                        size--;

                        fl = frnd_lst[i];
                        bl = block_lst[i];

                        for(j=0; j<fl.size(); j++)
                            if(dsu.find(i)  ==  dsu.find(fl.get(j)))
                                size--;

                        for(j=0; j<bl.size(); j++)
                            if(dsu.find(i)  ==  dsu.find(bl.get(j)))
                                size--;

                        if(i==0)
                            w.write(size+"");
                        else
                            w.write(" "+size);

                    }

                    



                    

    
    
                
                // }
                w.close();
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
                    
                    
    //========================================### FAST IO ###=========================================//
    class FastReader 
    { 
        BufferedReader br; 
        StringTokenizer st; 
    
        public FastReader() 
        { 
            br = new BufferedReader(new
                        InputStreamReader(System.in)); 
        } 
    
        String next() 
        { 
            while (st == null || !st.hasMoreElements()) 
            { 
                try
                { 
                    st = new StringTokenizer(br.readLine()); 
                } 
                catch (IOException  e) 
                { 
                    e.printStackTrace(); 
                } 
            } 
            return st.nextToken(); 
        } 
    
        int nextInt() 
        { 
            return Integer.parseInt(next()); 
        } 
    
        long nextLong() 
        { 
            return Long.parseLong(next()); 
        } 
    
        Double nextDouble() 
        { 
            return Double.parseDouble(next());
        } 
    
        String nextLine() 
        { 
            String str = ""; 
            try
            { 
                str = br.readLine(); 
            } 
            catch (IOException e) 
            { 
                e.printStackTrace(); 
            } 
            return str;
        } 
    }
        //====================================================================================================//