Buggy python submission (verdict: Time Limit Exceeded):
from collections import deque
N, M, K = map(int, input().split())
F = dict()
Block = dict()
for i in range(1, N+1):
    F[i] = []
    Block[i] = []

for _ in range(M):
    A, B = map(int, input().split())
    F[A].append(B)
    F[B].append(A)
for _ in range(K):
    C, D = map(int, input().split())
    Block[C].append(D)
    Block[D].append(C)

def dfs(i, F):
    cnt = 0
    visited = [False]*N
    visited[i-1] = True
    deq = deque(F[i])
    while deq:
        Q = deq.pop()
        if type(Q) == int:
            Q = [Q]
        for q in Q:
            if visited[q-1]:
                continue
            visited[q-1] = True
            cnt += 1
            if q in Block[i] or q in F[i]:
                cnt -= 1
            deq += F[q]
            deq = list(set(deq))
    return cnt

for i in range(1, N+1):
    if i != N:
        print(dfs(i, F), end=' ')
    else:
        print(dfs(i, F))

Fixed submission:
N, M, K = map(int, input().split())

class UnionFind:
    def __init__(self, n):
        self.ps = [-1] * (n + 1)
 
    def find(self, x):
        if self.ps[x] < 0:
            return x
        else:
            self.ps[x] = self.find(self.ps[x])
            return self.ps[x]
 
    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if x == y:
            return False
        if self.ps[x] > self.ps[y]:
            x, y = y, x
        self.ps[x] += self.ps[y]
        self.ps[y] = x
        return True
 
    def same(self, x, y):
        return self.find(x) == self.find(y)
 
    def size(self, x):
        x = self.find(x)
        return -self.ps[x]

uf = UnionFind(N)
friends = [0]*(N+1)
chain = [0]*(N+1)


for _ in range(M):
    A, B = map(int, input().split())
    friends[A] += 1
    friends[B] += 1
    uf.union(A, B)

for _ in range(K):
    C, D = map(int, input().split())
    if uf.same(C, D):
        friends[C] += 1
        friends[D] += 1

ans = []

for i in range(1, N+1):
    ans.append(uf.size(i) - friends[i] - 1)

print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
from collections import deque
N, M, K = map(int, input().split())
F = dict()
Block = dict()
for i in range(1, N+1):
    F[i] = []
    Block[i] = []

for _ in range(M):
    A, B = map(int, input().split())
    F[A].append(B)
    F[B].append(A)
for _ in range(K):
    C, D = map(int, input().split())
    Block[C].append(D)
    Block[D].append(C)

def dfs(i, F):
    cnt = 0
    visited = [False]*N
    visited[i-1] = True
    deq = deque(F[i])
    while deq:
        Q = deq.pop()
        if type(Q) == int:
            Q = [Q]
        for q in Q:
            if visited[q-1]:
                continue
            visited[q-1] = True
            cnt += 1
            if q in Block[i] or q in F[i]:
                cnt -= 1
            deq += F[q]
            deq = list(set(deq))
    return cnt

for i in range(1, N+1):
    if i != N:
        print(dfs(i, F), end=' ')
    else:
        print(dfs(i, F))

Fixed submission:
N, M, K = map(int, input().split())

class UnionFind:
    def __init__(self, n):
        self.ps = [-1] * (n + 1)
 
    def find(self, x):
        if self.ps[x] < 0:
            return x
        else:
            self.ps[x] = self.find(self.ps[x])
            return self.ps[x]
 
    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if x == y:
            return False
        if self.ps[x] > self.ps[y]:
            x, y = y, x
        self.ps[x] += self.ps[y]
        self.ps[y] = x
        return True
 
    def same(self, x, y):
        return self.find(x) == self.find(y)
 
    def size(self, x):
        x = self.find(x)
        return -self.ps[x]

uf = UnionFind(N)
friends = [0]*(N+1)
chain = [0]*(N+1)


for _ in range(M):
    A, B = map(int, input().split())
    friends[A] += 1
    friends[B] += 1
    uf.union(A, B)

for _ in range(K):
    C, D = map(int, input().split())
    if uf.same(C, D):
        friends[C] += 1
        friends[D] += 1

ans = []

for i in range(1, N+1):
    ans.append(uf.size(i) - friends[i] - 1)

print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
from collections import deque
N, M, K = map(int, input().split())
F = dict()
Block = dict()
for i in range(1, N+1):
    F[i] = []
    Block[i] = []

for _ in range(M):
    A, B = map(int, input().split())
    F[A].append(B)
    F[B].append(A)
for _ in range(K):
    C, D = map(int, input().split())
    Block[C].append(D)
    Block[D].append(C)

def dfs(i, F):
    cnt = 0
    visited = [False]*N
    visited[i-1] = True
    deq = deque(F[i])
    while deq:
        Q = deq.pop()
        if type(Q) == int:
            Q = [Q]
        for q in Q:
            if visited[q-1]:
                continue
            visited[q-1] = True
            if q not in F[i] and q not in Block[i]:
                cnt += 1
            deq += F[q]
            deq = list(set(deq))
    return cnt

for i in range(1, N+1):
    if i != N:
        print(dfs(i, F), end=' ')
    else:
        print(dfs(i, F))

Fixed submission:
N, M, K = map(int, input().split())

class UnionFind:
    def __init__(self, n):
        self.ps = [-1] * (n + 1)
 
    def find(self, x):
        if self.ps[x] < 0:
            return x
        else:
            self.ps[x] = self.find(self.ps[x])
            return self.ps[x]
 
    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if x == y:
            return False
        if self.ps[x] > self.ps[y]:
            x, y = y, x
        self.ps[x] += self.ps[y]
        self.ps[y] = x
        return True
 
    def same(self, x, y):
        return self.find(x) == self.find(y)
 
    def size(self, x):
        x = self.find(x)
        return -self.ps[x]

uf = UnionFind(N)
friends = [0]*(N+1)
chain = [0]*(N+1)


for _ in range(M):
    A, B = map(int, input().split())
    friends[A] += 1
    friends[B] += 1
    uf.union(A, B)

for _ in range(K):
    C, D = map(int, input().split())
    if uf.same(C, D):
        friends[C] += 1
        friends[D] += 1

ans = []

for i in range(1, N+1):
    ans.append(uf.size(i) - friends[i] - 1)

print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
from collections import deque
N, M, K = map(int, input().split())
F = dict()
Block = dict()
for i in range(1, N+1):
    F[i] = []
    Block[i] = []

for _ in range(M):
    A, B = map(int, input().split())
    F[A].append(B)
    F[B].append(A)
for _ in range(K):
    C, D = map(int, input().split())
    Block[C].append(D)
    Block[D].append(C)

def dfs(i, F):
    cnt = 0
    visited = [False]*N
    visited[i-1] = True
    deq = deque(F[i])
    while deq:
        Q = deq.pop()
        if type(Q) == int:
            Q = [Q]
        for q in Q:
            if visited[q-1]:
                continue
            visited[q-1] = True
            if q not in F[i] and  q not in Block[i]:
                cnt += 1
            deq.append(F[q])
    return cnt

for i in range(1, N+1):
    if i != N:
        print(dfs(i, F), end=' ')
    else:
        print(dfs(i, F))

Fixed submission:
N, M, K = map(int, input().split())

class UnionFind:
    def __init__(self, n):
        self.ps = [-1] * (n + 1)
 
    def find(self, x):
        if self.ps[x] < 0:
            return x
        else:
            self.ps[x] = self.find(self.ps[x])
            return self.ps[x]
 
    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if x == y:
            return False
        if self.ps[x] > self.ps[y]:
            x, y = y, x
        self.ps[x] += self.ps[y]
        self.ps[y] = x
        return True
 
    def same(self, x, y):
        return self.find(x) == self.find(y)
 
    def size(self, x):
        x = self.find(x)
        return -self.ps[x]

uf = UnionFind(N)
friends = [0]*(N+1)
chain = [0]*(N+1)


for _ in range(M):
    A, B = map(int, input().split())
    friends[A] += 1
    friends[B] += 1
    uf.union(A, B)

for _ in range(K):
    C, D = map(int, input().split())
    if uf.same(C, D):
        friends[C] += 1
        friends[D] += 1

ans = []

for i in range(1, N+1):
    ans.append(uf.size(i) - friends[i] - 1)

print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
N,M,K=map(int,input().split())
graph_data=[[0]*N for _ in range(N)]
block_data=[[0]*N for _ in range(N)]
    
for _ in range(M):
    i,j=map(int,input().split())
    graph_data[i-1][j-1]=graph_data[j-1][i-1]=1
for _ in range(K):
    i,j=map(int,input().split())
    block_data[i-1][j-1]=block_data[j-1][i-1]=1

from collections import deque

def bfs(start, W):
    work_queue = deque([])
    visited = set()
    work_queue.append(start)
    visited.add(start)
    while work_queue:
        here = work_queue.popleft()
        for i, node in enumerate(W[here]):
            if node ==0: continue
            if i not in visited:
                work_queue.append(i)
                visited.add(i)

    return visited

ans=[0]*N
for i in range(N):
    for j in bfs(i,graph_data):
        if i==j:continue
        if graph_data[i][j]==0:
            ans[i]+=1
        if block_data[i][j]==1:
            ans[i]-=1
pri=''
for i in range(N):
    pri+=str(ans[i])
    if i!=N-1:
        pri+=' '
print(pri)

Fixed submission:
N, M, K = map(int, input().split())

class UnionFind:
    def __init__(self, n):
        self.ps = [-1] * (n + 1)
 
    def find(self, x):
        if self.ps[x] < 0:
            return x
        else:
            self.ps[x] = self.find(self.ps[x])
            return self.ps[x]
 
    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if x == y:
            return False
        if self.ps[x] > self.ps[y]:
            x, y = y, x
        self.ps[x] += self.ps[y]
        self.ps[y] = x
        return True
 
    def same(self, x, y):
        return self.find(x) == self.find(y)
 
    def size(self, x):
        x = self.find(x)
        return -self.ps[x]

uf = UnionFind(N)
friends = [0]*(N+1)
chain = [0]*(N+1)


for _ in range(M):
    A, B = map(int, input().split())
    friends[A] += 1
    friends[B] += 1
    uf.union(A, B)

for _ in range(K):
    C, D = map(int, input().split())
    if uf.same(C, D):
        friends[C] += 1
        friends[D] += 1

ans = []

for i in range(1, N+1):
    ans.append(uf.size(i) - friends[i] - 1)

print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
N,M,K=map(int,input().split())
graph_data=[[0]*N for _ in range(N)]
block_data=[[0]*N for _ in range(N)]
edge_set=set()
block_set=set()
for i in range(N):
    graph_data[i][i]=1
for _ in range(M):
    i,j=map(int,input().split())
    edge_set.add((i,j))
    graph_data[i-1][j-1]=graph_data[j-1][i-1]=1
for _ in range(K):
    i,j=map(int,input().split())
    block_set.add((i,j))
    block_data[i-1][j-1]=block_data[j-1][i-1]=1

from collections import deque

def bfs(start, W):
    work_queue = deque([])
    visited = set()
    work_queue.append(start)
    visited.add(start)
    while work_queue:
        here = work_queue.popleft()
        for i, node in enumerate(W[here]):
            if node ==0: continue
            if i not in visited:
                work_queue.append(i)
                visited.add(i)

    return visited

ans=[0]*N
for i in range(N):
    for j in bfs(i,graph_data):
        if graph_data[i][j]==0:
            ans[i]+=1
        if block_data[i][j]==1:
            ans[i]-=1
pri=''
for i in range(N):
    pri+=str(ans[i])
    if i!=N-1:
        pri+=' '
print(pri)

Fixed submission:
N, M, K = map(int, input().split())

class UnionFind:
    def __init__(self, n):
        self.ps = [-1] * (n + 1)
 
    def find(self, x):
        if self.ps[x] < 0:
            return x
        else:
            self.ps[x] = self.find(self.ps[x])
            return self.ps[x]
 
    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if x == y:
            return False
        if self.ps[x] > self.ps[y]:
            x, y = y, x
        self.ps[x] += self.ps[y]
        self.ps[y] = x
        return True
 
    def same(self, x, y):
        return self.find(x) == self.find(y)
 
    def size(self, x):
        x = self.find(x)
        return -self.ps[x]

uf = UnionFind(N)
friends = [0]*(N+1)
chain = [0]*(N+1)


for _ in range(M):
    A, B = map(int, input().split())
    friends[A] += 1
    friends[B] += 1
    uf.union(A, B)

for _ in range(K):
    C, D = map(int, input().split())
    if uf.same(C, D):
        friends[C] += 1
        friends[D] += 1

ans = []

for i in range(1, N+1):
    ans.append(uf.size(i) - friends[i] - 1)

print(*ans)