Buggy python submission (verdict: Time Limit Exceeded):
from collections import defaultdict

class UnionFind():
  def __init__(self, n):
    self.n = n
    self.parents = [-1] * n
    
  def find(self, x):
    if self.parents[x] < 0:
      return x
    else:
      self.parents[x] = self.find(self.parents[x])
      return self.parents[x]

  def union(self, x, y):
    x = self.find(x)
    y = self.find(y)

    if x == y:
        return

    if self.parents[x] > self.parents[y]:
        x, y = y, x

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

  def size(self, x):
    return -self.parents[self.find(x)]

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

  def members(self, x):
    root = self.find(x)
    return [i for i in range(self.n) if self.find(i) == root]

  def roots(self):
    return [i for i, x in enumerate(self.parents) if x < 0]

  def group_count(self):
    return len(self.roots())

  def all_group_members(self):
    return {r: self.members(r) for r in self.roots()}

  def __str__(self):
    return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

n, m, k = map(int, input().split())
AB = [list(map(int, input().split())) for _ in range(m)]
CD = [list(map(int, input().split())) for _ in range(k)]

fre = defaultdict(set)
for a, b in AB:
  fre[a - 1].add(b - 1)
  fre[b - 1].add(a - 1)

blo = defaultdict(set)
for c, d in CD:
  blo[c - 1].add(d - 1)
  blo[d - 1].add(c - 1)

#print(fre)
#print(blo)

uf = UnionFind(n)
for a, b in AB:
  uf.union(a-1, b-1)
#print(uf)
print(*[len(set(uf.members(i)) - fre[i] - blo[i]) - 1 for i in range(n)])

Fixed submission:
from collections import defaultdict

class UnionFind():
  def __init__(self, n):
    self.n = n
    self.parents = [-1] * n
    
  def find(self, x):
    if self.parents[x] < 0:
      return x
    else:
      self.parents[x] = self.find(self.parents[x])
      return self.parents[x]

  def union(self, x, y):
    x = self.find(x)
    y = self.find(y)

    if x == y:
        return

    if self.parents[x] > self.parents[y]:
        x, y = y, x

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

  def size(self, x):
    return -self.parents[self.find(x)]

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

  def members(self, x):
    root = self.find(x)
    return [i for i in range(self.n) if self.find(i) == root]

  def roots(self):
    return [i for i, x in enumerate(self.parents) if x < 0]

  def group_count(self):
    return len(self.roots())

  def all_group_members(self):
    return {r: self.members(r) for r in self.roots()}

  def __str__(self):
    return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

n, m, k = map(int, input().split())
AB = [list(map(int, input().split())) for _ in range(m)]
CD = [list(map(int, input().split())) for _ in range(k)]

uf = UnionFind(n)
fre = [0] * n
for a, b in AB:
  fre[a - 1] += 1
  fre[b - 1] += 1
  uf.union(a - 1, b - 1)

blo = [0] * n
for c, d in CD:
  if uf.same(c - 1, d - 1):
    blo[c - 1] += 1
    blo[d - 1] += 1

rs = uf.roots()
cnt = {r: uf.size(r) for r in rs}

ans = []
for i in range(n):
    r = uf.find(i)
    ans.append(cnt[r] - fre[i] - blo[i] - 1)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
from collections import defaultdict

class UnionFind():
  def __init__(self, n):
    self.n = n
    self.parents = [-1] * n
    
  def find(self, x):
    if self.parents[x] < 0:
      return x
    else:
      self.parents[x] = self.find(self.parents[x])
      return self.parents[x]

  def union(self, x, y):
    x = self.find(x)
    y = self.find(y)

    if x == y:
        return

    if self.parents[x] > self.parents[y]:
        x, y = y, x

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

  def size(self, x):
    return -self.parents[self.find(x)]

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

  def members(self, x):
    root = self.find(x)
    return [i for i in range(self.n) if self.find(i) == root]

  def roots(self):
    return [i for i, x in enumerate(self.parents) if x < 0]

  def group_count(self):
    return len(self.roots())

  def all_group_members(self):
    return {r: self.members(r) for r in self.roots()}

  def __str__(self):
    return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

n, m, k = map(int, input().split())
AB = [list(map(int, input().split())) for _ in range(m)]
CD = [list(map(int, input().split())) for _ in range(k)]

fre = defaultdict(set)
for a, b in AB:
  fre[a - 1].add(b - 1)
  fre[b - 1].add(a - 1)

blo = defaultdict(set)
for c, d in CD:
  blo[c - 1].add(d - 1)
  blo[d - 1].add(c - 1)

#print(fre)
#print(blo)

uf = UnionFind(n)
for a, b in AB:
  uf.union(a-1, b-1)
#print(uf)
print(*[len(set(uf.members(i)) - fre[i] - blo[i]) - 1 for i in range(n)])

Fixed submission:
from collections import defaultdict

class UnionFind():
  def __init__(self, n):
    self.n = n
    self.parents = [-1] * n
    
  def find(self, x):
    if self.parents[x] < 0:
      return x
    else:
      self.parents[x] = self.find(self.parents[x])
      return self.parents[x]

  def union(self, x, y):
    x = self.find(x)
    y = self.find(y)

    if x == y:
        return

    if self.parents[x] > self.parents[y]:
        x, y = y, x

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

  def size(self, x):
    return -self.parents[self.find(x)]

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

  def members(self, x):
    root = self.find(x)
    return [i for i in range(self.n) if self.find(i) == root]

  def roots(self):
    return [i for i, x in enumerate(self.parents) if x < 0]

  def group_count(self):
    return len(self.roots())

  def all_group_members(self):
    return {r: self.members(r) for r in self.roots()}

  def __str__(self):
    return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

n, m, k = map(int, input().split())
AB = [list(map(int, input().split())) for _ in range(m)]
CD = [list(map(int, input().split())) for _ in range(k)]

uf = UnionFind(n)
fre = [0] * n
for a, b in AB:
  fre[a - 1] += 1
  fre[b - 1] += 1
  uf.union(a - 1, b - 1)

blo = [0] * n
for c, d in CD:
  if uf.same(c - 1, d - 1):
    blo[c - 1] += 1
    blo[d - 1] += 1

rs = uf.roots()
cnt = {r: uf.size(r) for r in rs}

ans = []
for i in range(n):
    r = uf.find(i)
    ans.append(cnt[r] - fre[i] - blo[i] - 1)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
from collections import defaultdict

class UnionFind():
  def __init__(self, n):
    self.n = n
    self.parents = [-1] * n
    
  def find(self, x):
    if self.parents[x] < 0:
      return x
    else:
      self.parents[x] = self.find(self.parents[x])
      return self.parents[x]

  def union(self, x, y):
    x = self.find(x)
    y = self.find(y)

    if x == y:
        return

    if self.parents[x] > self.parents[y]:
        x, y = y, x

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

  def size(self, x):
    return -self.parents[self.find(x)]

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

  def members(self, x):
    root = self.find(x)
    return [i for i in range(self.n) if self.find(i) == root]

  def roots(self):
    return [i for i, x in enumerate(self.parents) if x < 0]

  def group_count(self):
    return len(self.roots())

  def all_group_members(self):
    return {r: self.members(r) for r in self.roots()}

  def __str__(self):
    return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

n, m, k = map(int, input().split())
AB = [list(map(int, input().split())) for _ in range(m)]
CD = [list(map(int, input().split())) for _ in range(k)]

fre = defaultdict(list)
for a, b in AB:
  fre[a - 1].append(b - 1)
  fre[b - 1].append(a - 1)

blo = defaultdict(list)
for c, d in CD:
  blo[c - 1].append(d - 1)
  blo[d - 1].append(c - 1)

#print(fre)
#print(blo)

uf = UnionFind(n)
for a, b in AB:
  uf.union(a-1, b-1)
#print(uf)
print(*[len(set(uf.members(i)) - set(fre[i]) - set(blo[i])) - 1 for i in range(n)])

Fixed submission:
from collections import defaultdict

class UnionFind():
  def __init__(self, n):
    self.n = n
    self.parents = [-1] * n
    
  def find(self, x):
    if self.parents[x] < 0:
      return x
    else:
      self.parents[x] = self.find(self.parents[x])
      return self.parents[x]

  def union(self, x, y):
    x = self.find(x)
    y = self.find(y)

    if x == y:
        return

    if self.parents[x] > self.parents[y]:
        x, y = y, x

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

  def size(self, x):
    return -self.parents[self.find(x)]

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

  def members(self, x):
    root = self.find(x)
    return [i for i in range(self.n) if self.find(i) == root]

  def roots(self):
    return [i for i, x in enumerate(self.parents) if x < 0]

  def group_count(self):
    return len(self.roots())

  def all_group_members(self):
    return {r: self.members(r) for r in self.roots()}

  def __str__(self):
    return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

n, m, k = map(int, input().split())
AB = [list(map(int, input().split())) for _ in range(m)]
CD = [list(map(int, input().split())) for _ in range(k)]

uf = UnionFind(n)
fre = [0] * n
for a, b in AB:
  fre[a - 1] += 1
  fre[b - 1] += 1
  uf.union(a - 1, b - 1)

blo = [0] * n
for c, d in CD:
  if uf.same(c - 1, d - 1):
    blo[c - 1] += 1
    blo[d - 1] += 1

rs = uf.roots()
cnt = {r: uf.size(r) for r in rs}

ans = []
for i in range(n):
    r = uf.find(i)
    ans.append(cnt[r] - fre[i] - blo[i] - 1)
print(*ans)