Buggy python submission (verdict: Time Limit Exceeded):
class UnionFind:
    def __init__(self, data):
        """
        サイズベースのunion_find
        与えられたdataまでの長さの配列を作成
        配列は1から開始する
        それがunionfindの親となり初めは自分自身
        またsizeも定義し初期値は1
        ・union findのグループのサイズの求め方
        1.あるxのグループの親を取得
        union_find = UnionFind(N)
        par_x = union_find.find(x)
        2.その親のsizeがそのグループのサイズになっている
        size = union_find.size[par_x]
        """
        self.parent = {}
        self.size = {}
        for i in range(1, data+1):
            self.parent[i] = i
            self.size[i] = 1


    def find(self, x):
        """
        与えられた値に対してその親ノードを返却
        """
        if self.parent[x] == x:
            return x
        else:
            self.parent[x] = self.find(self.parent[x]) # self.parentに入れ直しているのは次findするとき高速になるよう再起により親を直接結んでいる
            return self.parent[x]


    def same(self, x, y):
        """
        与えられた2つの値が同一グループ(親)かチェック
        """
        return self.find(x) == self.find(y)


    def unite(self, x, y):
        """
        与えられた2つの値を同一のグループ(親)にする
        """
        x = self.find(x)
        y = self.find(y)
        if x == y: # すでに同じグループなら何もしない
            return
        if self.size[x] > self.size[y]: # ランクが異なる場合小さい方の親を大きい方にする
            self.parent[y] = x
            self.size[x] += self.size[y]
            return
        elif self.size[x] < self.size[y]:
            self.parent[x] = y
            self.size[y] += self.size[x]
            return
        else: # ランクが同じ場合どちらかの親にする その際親にした方の値のランクをあげる
            self.parent[x] = y
            if self.size[x] == self.size[y]: self.size[y] += self.size[x]
            return

if __name__ == '__main__':
    N,M,K = map(int, input().split())
    union_find = UnionFind(N)

    kankei = [[] for i in range(N+1)]
    for i in range(M):
        A,B = map(int, input().split())
        union_find.unite(A,B)
        if B in kankei[A]:
            continue
        else:
            kankei[A].append(B)
            kankei[B].append(A)

    for i in range(K):
        C,D = map(int, input().split())
        if union_find.same(C,D):
            if D not in kankei[C]:
                kankei[C].append(D)
                kankei[D].append(C)

    ans = ""
    for i in range(1,N+1):
        ans += str(union_find.size[union_find.find(i)]-len(kankei[i])-1) + " "

    print(ans.rstrip())

Fixed submission:
class UnionFind:
    def __init__(self, data):
        """
        サイズベースのunion_find
        与えられたdataまでの長さの配列を作成
        配列は1から開始する
        それがunionfindの親となり初めは自分自身
        またsizeも定義し初期値は1
        ・union findのグループのサイズの求め方
        1.あるxのグループの親を取得
        union_find = UnionFind(N)
        par_x = union_find.find(x)
        2.その親のsizeがそのグループのサイズになっている
        size = union_find.size[par_x]
        """
        self.parent = {}
        self.size = {}
        for i in range(1, data+1):
            self.parent[i] = i
            self.size[i] = 1


    def find(self, x):
        """
        与えられた値に対してその親ノードを返却
        """
        if self.parent[x] == x:
            return x
        else:
            self.parent[x] = self.find(self.parent[x]) # self.parentに入れ直しているのは次findするとき高速になるよう再起により親を直接結んでいる
            return self.parent[x]


    def same(self, x, y):
        """
        与えられた2つの値が同一グループ(親)かチェック
        """
        return self.find(x) == self.find(y)


    def unite(self, x, y):
        """
        与えられた2つの値を同一のグループ(親)にする
        """
        x = self.find(x)
        y = self.find(y)
        if x == y: # すでに同じグループなら何もしない
            return
        if self.size[x] > self.size[y]: # ランクが異なる場合小さい方の親を大きい方にする
            self.parent[y] = x
            self.size[x] += self.size[y]
            return
        elif self.size[x] < self.size[y]:
            self.parent[x] = y
            self.size[y] += self.size[x]
            return
        else: # ランクが同じ場合どちらかの親にする その際親にした方の値のランクをあげる
            self.parent[x] = y
            if self.size[x] == self.size[y]: self.size[y] += self.size[x]
            return

if __name__ == '__main__':
    N,M,K = map(int, input().split())
    union_find = UnionFind(N)

    kankei = [[] for i in range(N+1)]
    for i in range(M):
        A,B = map(int, input().split())
        union_find.unite(A,B)
        kankei[A].append(B)
        kankei[B].append(A)

    for i in range(K):
        C,D = map(int, input().split())
        if union_find.same(C,D):
            kankei[C].append(D)
            kankei[D].append(C)

    ans = ""
    for i in range(1,N+1):
        ans += str(union_find.size[union_find.find(i)]-len(kankei[i])-1) + " "

    print(ans.rstrip())

Buggy python submission (verdict: Time Limit Exceeded):
class UnionFind:
    def __init__(self, data):
        """
        サイズベースのunion_find
        与えられたdataまでの長さの配列を作成
        配列は1から開始する
        それがunionfindの親となり初めは自分自身
        またsizeも定義し初期値は1
        ・union findのグループのサイズの求め方
        1.あるxのグループの親を取得
        union_find = UnionFind(N)
        par_x = union_find.find(x)
        2.その親のsizeがそのグループのサイズになっている
        size = union_find.size[par_x]
        """
        self.parent = {}
        self.size = {}
        for i in range(1, data+1):
            self.parent[i] = i
            self.size[i] = 1


    def find(self, x):
        """
        与えられた値に対してその親ノードを返却
        """
        if self.parent[x] == x:
            return x
        else:
            self.parent[x] = self.find(self.parent[x]) # self.parentに入れ直しているのは次findするとき高速になるよう再起により親を直接結んでいる
            return self.parent[x]


    def same(self, x, y):
        """
        与えられた2つの値が同一グループ(親)かチェック
        """
        return self.find(x) == self.find(y)


    def unite(self, x, y):
        """
        与えられた2つの値を同一のグループ(親)にする
        """
        x = self.find(x)
        y = self.find(y)
        if x == y: # すでに同じグループなら何もしない
            return
        if self.size[x] > self.size[y]: # ランクが異なる場合小さい方の親を大きい方にする
            self.parent[y] = x
            self.size[x] += self.size[y]
            return
        elif self.size[x] < self.size[y]:
            self.parent[x] = y
            self.size[y] += self.size[x]
            return
        else: # ランクが同じ場合どちらかの親にする その際親にした方の値のランクをあげる
            self.parent[x] = y
            if self.size[x] == self.size[y]: self.size[y] += self.size[x]
            return

if __name__ == '__main__':
    N,M,K = map(int, input().split())
    union_find = UnionFind(N)

    kankei = [[] for i in range(N+1)]
    for i in range(M):
        A,B = map(int, input().split())
        union_find.unite(A,B)
        if B in kankei[A]:
            continue
        else:
            kankei[A].append(B)
            kankei[B].append(A)

    for i in range(K):
        C,D = map(int, input().split())
        if union_find.same(C,D):
            if D not in kankei[C]:
                kankei[C].append(D)
                kankei[D].append(C)

    ans = ""
    for i in range(1,N+1):
        ans += str(union_find.size[union_find.find(i)]-len(kankei[i])-1) + " "

    print(ans.rstrip())

Fixed submission:
class UnionFind:
    def __init__(self, data):
        """
        サイズベースのunion_find
        与えられたdataまでの長さの配列を作成
        配列は1から開始する
        それがunionfindの親となり初めは自分自身
        またsizeも定義し初期値は1
        ・union findのグループのサイズの求め方
        1.あるxのグループの親を取得
        union_find = UnionFind(N)
        par_x = union_find.find(x)
        2.その親のsizeがそのグループのサイズになっている
        size = union_find.size[par_x]
        """
        self.parent = {}
        self.size = {}
        for i in range(1, data+1):
            self.parent[i] = i
            self.size[i] = 1


    def find(self, x):
        """
        与えられた値に対してその親ノードを返却
        """
        if self.parent[x] == x:
            return x
        else:
            self.parent[x] = self.find(self.parent[x]) # self.parentに入れ直しているのは次findするとき高速になるよう再起により親を直接結んでいる
            return self.parent[x]


    def same(self, x, y):
        """
        与えられた2つの値が同一グループ(親)かチェック
        """
        return self.find(x) == self.find(y)


    def unite(self, x, y):
        """
        与えられた2つの値を同一のグループ(親)にする
        """
        x = self.find(x)
        y = self.find(y)
        if x == y: # すでに同じグループなら何もしない
            return
        if self.size[x] > self.size[y]: # ランクが異なる場合小さい方の親を大きい方にする
            self.parent[y] = x
            self.size[x] += self.size[y]
            return
        elif self.size[x] < self.size[y]:
            self.parent[x] = y
            self.size[y] += self.size[x]
            return
        else: # ランクが同じ場合どちらかの親にする その際親にした方の値のランクをあげる
            self.parent[x] = y
            if self.size[x] == self.size[y]: self.size[y] += self.size[x]
            return

if __name__ == '__main__':
    N,M,K = map(int, input().split())
    union_find = UnionFind(N)

    kankei = [[] for i in range(N+1)]
    for i in range(M):
        A,B = map(int, input().split())
        union_find.unite(A,B)
        kankei[A].append(B)
        kankei[B].append(A)

    for i in range(K):
        C,D = map(int, input().split())
        if union_find.same(C,D):
            kankei[C].append(D)
            kankei[D].append(C)

    ans = ""
    for i in range(1,N+1):
        ans += str(union_find.size[union_find.find(i)]-len(kankei[i])-1) + " "

    print(ans.rstrip())