class UnionFind():

 def __init__(self,n):

   self.n=n

   self.root=[-1]*(n+1)

   self.rank=[0]*(n+1)

 def FindRoot(self,x):

   if self.root[x]<0:

     return x

   else:

     self.root[x]=self.FindRoot(self.root[x])

     return self.root[x]

 def Unite(self,x,y):

   x=self.FindRoot(x)

   y=self.FindRoot(y)

   if x==y:

     return

   else:

     if self.rank[x]>self.rank[y]:

       self.root[x]+=self.root[y]

       self.root[y]=x

     elif self.rank[x]<=self.rank[y]:

       self.root[y]+=self.root[x]

       self.root[x]=y

       if self.rank[x]==self.rank[y]:

         self.rank[y]+=1

 def isSameGroup(self,x,y):

   return self.FindRoot(x)==self.FindRoot(y)

 def Count(self,x):

   return -self.root[self.FindRoot(x)]

 

n,m,k=list(map(int,input().split()))

t=UnionFind(n)

cnt=[0]*(n+1) #各iについて、iと同一の連結成分に属する友達関係の人、ブロック関係の人の数を数える

for _ in range(m):

 a,b=list(map(int,input().split()))

 cnt[a]+=1 #各iについて、iと同一の連結成分に属する友達関係の人の数を数える

 cnt[b]+=1

 t.Unite(a,b)

for _ in range(k):

 a,b=list(map(int,input().split()))

 if t.isSameGroup(a,b)==True:

   cnt[a]+=1 #各iについて、iと同一の連結成分に属するブロック関係の人の数を数える

   cnt[b]+=1

ans=[0]*(n+1)

for i in range(1,n+1):

 ans[i]=(t.Count(i)-1)-cnt[i] #答えは(各iが属する連結成分のサイズ)-1-((iと同一の連結成分に含まれているiと友達関係にある人の数)+(iと同一の連結成分に含まれているiとブロック関係にある人の数)となる

print((*ans[1:]))
import sys

 

 

class UnionFind:

    def __init__(self, n):

        self.table = [-1] * n

 

    def _root(self, x):

        if self.table[x] < 0:

            return x

        else:

            self.table[x] = self._root(self.table[x])

            return self.table[x]

 

    def count(self, x):

        return -self.table[self._root(x)]

 

    def find(self, x, y):

        return self._root(x) == self._root(y)

 

    def union(self, x, y):

        r1 = self._root(x)

        r2 = self._root(y)

        if r1 == r2:

            return

        d1 = self.table[r1]

        d2 = self.table[r2]

        if d1 <= d2:

            self.table[r2] = r1

            self.table[r1] += d2

        else:

            self.table[r1] = r2

            self.table[r2] += d1

 

 

n, m, k = list(map(int, sys.stdin.buffer.readline().split()))

abcd = list(map(int, sys.stdin.buffer.read().split()))

uft = UnionFind(n)

friends = [0 for _ in range(n)]

blocks = [set() for _ in range(n)]

for a, b in zip(abcd[0:2 * m:2], abcd[1:2 * m:2]):

    a -= 1

    b -= 1

    uft.union(a, b)

    friends[a] += 1

    friends[b] += 1

for c, d in zip(abcd[2 * m::2], abcd[2 * m + 1::2]):

    c -= 1

    d -= 1

    blocks[c].add(d)

    blocks[d].add(c)

ans = []

for i in range(n):

    ans.append(uft.count(i) - 1 - friends[i] - sum(uft.find(i, j) for j in blocks[i]))

print((*ans))
class UnionFind:
    def __init__(self, n):
        self.n = n
        self.root = [-1] * (n + 1)
        self.rank = [0] * (n + 1)

    def FindRoot(self, x):
        if self.root[x] < 0:
            return x
        else:
            self.root[x] = self.FindRoot(self.root[x])
            return self.root[x]

    def Unite(self, x, y):
        x = self.FindRoot(x)
        y = self.FindRoot(y)
        if x == y:
            return
        else:
            if self.rank[x] > self.rank[y]:
                self.root[x] += self.root[y]
                self.root[y] = x
            elif self.rank[x] <= self.rank[y]:
                self.root[y] += self.root[x]
                self.root[x] = y
                if self.rank[x] == self.rank[y]:
                    self.rank[y] += 1

    def isSameGroup(self, x, y):
        return self.FindRoot(x) == self.FindRoot(y)

    def Count(self, x):
        return -self.root[self.FindRoot(x)]


n, m, k = list(map(int, input().split()))
t = UnionFind(n)
cnt = [0] * (n + 1)  # 各iについて、iと同一の連結成分に属する友達関係の人、ブロック関係の人の数を数える
for _ in range(m):
    a, b = list(map(int, input().split()))
    cnt[a] += 1  # 各iについて、iと同一の連結成分に属する友達関係の人の数を数える
    cnt[b] += 1
    t.Unite(a, b)
for _ in range(k):
    a, b = list(map(int, input().split()))
    if t.isSameGroup(a, b) == True:
        cnt[a] += 1  # 各iについて、iと同一の連結成分に属するブロック関係の人の数を数える
        cnt[b] += 1
ans = [0] * (n + 1)
for i in range(1, n + 1):
    ans[i] = (t.Count(i) - 1) - cnt[
        i
    ]  # 答えは(各iが属する連結成分のサイズ)-1-((iと同一の連結成分に含まれているiと友達関係にある人の数)+(iと同一の連結成分に含まれているiとブロック関係にある人の数)となる
print((*ans[1:]))

import sys


class UnionFind:
    def __init__(self, n):
        self.table = [-1] * n

    def _root(self, x):
        if self.table[x] < 0:
            return x
        else:
            self.table[x] = self._root(self.table[x])
            return self.table[x]

    def count(self, x):
        return -self.table[self._root(x)]

    def find(self, x, y):
        return self._root(x) == self._root(y)

    def union(self, x, y):
        r1 = self._root(x)
        r2 = self._root(y)
        if r1 == r2:
            return
        d1 = self.table[r1]
        d2 = self.table[r2]
        if d1 <= d2:
            self.table[r2] = r1
            self.table[r1] += d2
        else:
            self.table[r1] = r2
            self.table[r2] += d1


n, m, k = list(map(int, sys.stdin.buffer.readline().split()))
abcd = list(map(int, sys.stdin.buffer.read().split()))
uft = UnionFind(n)
friends = [0 for _ in range(n)]
blocks = [set() for _ in range(n)]
for a, b in zip(abcd[0 : 2 * m : 2], abcd[1 : 2 * m : 2]):
    a -= 1
    b -= 1
    uft.union(a, b)
    friends[a] += 1
    friends[b] += 1
for c, d in zip(abcd[2 * m :: 2], abcd[2 * m + 1 :: 2]):
    c -= 1
    d -= 1
    blocks[c].add(d)
    blocks[d].add(c)
ans = []
for i in range(n):
    ans.append(uft.count(i) - 1 - friends[i] - sum(uft.find(i, j) for j in blocks[i]))
print((*ans))

+import sys + + -        self.n = n -        self.root = [-1] * (n + 1) -        self.rank = [0] * (n + 1) +        self.table = [-1] * n -    def FindRoot(self, x): -        if self.root[x] < 0: +    def _root(self, x): +        if self.table[x] < 0: -            self.root[x] = self.FindRoot(self.root[x]) -            return self.root[x] +            self.table[x] = self._root(self.table[x]) +            return self.table[x] -    def Unite(self, x, y): -        x = self.FindRoot(x) -        y = self.FindRoot(y) -        if x == y: +    def count(self, x): +        return -self.table[self._root(x)] + +    def find(self, x, y): +        return self._root(x) == self._root(y) + +    def union(self, x, y): +        r1 = self._root(x) +        r2 = self._root(y) +        if r1 == r2: +        d1 = self.table[r1] +        d2 = self.table[r2] +        if d1 <= d2: +            self.table[r2] = r1 +            self.table[r1] += d2 -            if self.rank[x] > self.rank[y]: -                self.root[x] += self.root[y] -                self.root[y] = x -            elif self.rank[x] <= self.rank[y]: -                self.root[y] += self.root[x] -                self.root[x] = y -                if self.rank[x] == self.rank[y]: -                    self.rank[y] += 1 - -    def isSameGroup(self, x, y): -        return self.FindRoot(x) == self.FindRoot(y) - -    def Count(self, x): -        return -self.root[self.FindRoot(x)] +            self.table[r1] = r2 +            self.table[r2] += d1 -n, m, k = list(map(int, input().split())) -t = UnionFind(n) -cnt = [0] * (n + 1)  # 各iについて、iと同一の連結成分に属する友達関係の人、ブロック関係の人の数を数える -for _ in range(m): -    a, b = list(map(int, input().split())) -    cnt[a] += 1  # 各iについて、iと同一の連結成分に属する友達関係の人の数を数える -    cnt[b] += 1 -    t.Unite(a, b) -for _ in range(k): -    a, b = list(map(int, input().split())) -    if t.isSameGroup(a, b) == True: -        cnt[a] += 1  # 各iについて、iと同一の連結成分に属するブロック関係の人の数を数える -        cnt[b] += 1 -ans = [0] * (n + 1) -for i in range(1, n + 1): -    ans[i] = (t.Count(i) - 1) - cnt[ -        i -    ]  # 答えは(各iが属する連結成分のサイズ)-1-((iと同一の連結成分に含まれているiと友達関係にある人の数)+(iと同一の連結成分に含まれているiとブロック関係にある人の数)となる -print((*ans[1:])) +n, m, k = list(map(int, sys.stdin.buffer.readline().split())) +abcd = list(map(int, sys.stdin.buffer.read().split())) +uft = UnionFind(n) +friends = [0 for _ in range(n)] +blocks = [set() for _ in range(n)] +for a, b in zip(abcd[0 : 2 * m : 2], abcd[1 : 2 * m : 2]): +    a -= 1 +    b -= 1 +    uft.union(a, b) +    friends[a] += 1 +    friends[b] += 1 +for c, d in zip(abcd[2 * m :: 2], abcd[2 * m + 1 :: 2]): +    c -= 1 +    d -= 1 +    blocks[c].add(d) +    blocks[d].add(c) +ans = [] +for i in range(n): +    ans.append(uft.count(i) - 1 - friends[i] - sum(uft.find(i, j) for j in blocks[i])) +print((*ans))