Buggy python submission (verdict: Time Limit Exceeded):
import queue
import sys 
input=sys.stdin.readline

def main():
    n,m,k=map(int,input().split())
    root={}
    ng={}

    for i in range(n):
        root[i]=[]
        ng[i]=[]
    for i in range(m):
        a,b=map(int,input().split())
        root[a-1].append(b-1)
        root[b-1].append(a-1)
    for i in range(k):
        a,b=map(int,input().split())
        ng[a-1].append(b-1)
        ng[b-1].append(a-1)
    
    Vstd=[]
    v_append=Vstd.append
    checkVst=[False]*n
    num=[0]*n
    ToVst=queue.Queue()
    for i in range(n):
        if checkVst[i]:
            continue
        Vstd=[]
        v_append=Vstd.append
        now=i
        v_append(now)
        checkVst[now]=True

        for kouho in root[now]:
            if checkVst[kouho]:
                continue
            ToVst.put(kouho)
            checkVst[kouho]=True

        while ToVst.empty()==False:
            now=ToVst.get()
            v_append(now)
            checkVst[now]=True
           
            for kouho in root[now]:
                if checkVst[kouho]:
                    continue
                ToVst.put(kouho)
                checkVst[kouho]=True
                
        lengh=len(Vstd)
        for v in Vstd:
            num[v]=lengh-1
            num[v]-=len((set(ng[v]) | set(root[v]))&set(Vstd))
    print(*num)
    #print(" ".join(map(str,num)))
   

if __name__=="__main__":
    main()
    

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
import queue
import sys 
input=sys.stdin.readline

def main():
    n,m,k=map(int,input().split())
    root={}
    ng={}

    for i in range(n):
        root[i]=[]
        ng[i]=[]
    for i in range(m):
        a,b=map(int,input().split())
        root[a-1].append(b-1)
        root[b-1].append(a-1)
     #   ng[a-1].append(b-1)
      #  ng[b-1].append(a-1)
    for i in range(k):
        a,b=map(int,input().split())
        ng[a-1].append(b-1)
        ng[b-1].append(a-1)
    
    Vstd=[]
    v_append=Vstd.append
    checkVst=[False]*n
    num=[0]*n
    ToVst=queue.Queue()
    for i in range(n):
        if checkVst[i]:
            continue
        Vstd=[]
        v_append=Vstd.append
        now=i
        v_append(now)
        checkVst[now]=True

        for kouho in root[now]:
            if checkVst[kouho]:
                continue
            ToVst.put(kouho)
            checkVst[kouho]=True

        while ToVst.empty()==False:
            now=ToVst.get()
            v_append(now)
            checkVst[now]=True
           
            for kouho in root[now]:
                if checkVst[kouho]:
                    continue
                ToVst.put(kouho)
                checkVst[kouho]=True
                
        lengh=len(Vstd)
        for v in Vstd:
            num[v]=lengh-1
            num[v]-=len((set(ng[v]) | set(root[v]))&set(Vstd))
    print(*num)
    #print(" ".join(map(str,num)))
   

if __name__=="__main__":
    main()
    
        

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
import queue
import sys 
input=sys.stdin.readline

def main():
    n,m,k=map(int,input().split())
    root={}
    ng={}

    for i in range(n):
        root[i]=[]
        ng[i]=[]
    for i in range(m):
        a,b=map(int,input().split())
        root[a-1].append(b-1)
        root[b-1].append(a-1)
        ng[a-1].append(b-1)
        ng[b-1].append(a-1)
    for i in range(k):
        a,b=map(int,input().split())
        ng[a-1].append(b-1)
        ng[b-1].append(a-1)
    
    Vstd=[]
    v_append=Vstd.append
    checkVst=[False]*n
    num=[0]*n
    ToVst=queue.Queue()
    for i in range(n):
        if checkVst[i]:
            continue
        Vstd=[]
        v_append=Vstd.append
        now=i
        v_append(now)
        checkVst[now]=True

        for kouho in root[now]:
            if checkVst[kouho]:
                continue
            ToVst.put(kouho)
            checkVst[kouho]=True

        while ToVst.empty()==False:
            now=ToVst.get()
            v_append(now)
            checkVst[now]=True
           
            for kouho in root[now]:
                if checkVst[kouho]:
                    continue
                ToVst.put(kouho)
                checkVst[kouho]=True
                
        lengh=len(Vstd)
        for v in Vstd:
            num[v]=lengh-1
            num[v]-=len(set(ng[v])&set(Vstd))
    print(*num)
    #print(" ".join(map(str,num)))
   

if __name__=="__main__":
    main()
    
        

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
import queue
import sys 
input=sys.stdin.readline
def main():
    n,m,k=map(int,input().split())
    root={}
    ng={}
    for i in range(n):
        root[i]=[]
        ng[i]=[]
    for i in range(m):
        a,b=map(int,input().split())
        root[a-1].append(b-1)
        root[b-1].append(a-1)
        ng[a-1].append(b-1)
        ng[b-1].append(a-1)
    for i in range(k):
        a,b=map(int,input().split())
        ng[a-1].append(b-1)
        ng[b-1].append(a-1)
    
    Vstd=[]
    checkVst=[False]*n
    num=[0]*n
    ToVst=queue.Queue()
   
    for i in range(n):
        if checkVst[i]:
            continue
        Vstd=[]
        now=i
        Vstd.append(now)
        checkVst[now]=True

        for kouho in root[now]:
            if checkVst[kouho]:
                continue
            ToVst.put(kouho)
            checkVst[kouho]=True

        while ToVst.empty()==False:
            now=ToVst.get()
            Vstd.append(now)
            checkVst[now]=True
           
            for kouho in root[now]:
                if checkVst[kouho]:
                    continue
                ToVst.put(kouho)
                checkVst[kouho]=True
                
        lengh=len(Vstd)
        for v in Vstd:
            num[v]=lengh-1
            num[v]-=len(set(ng[v])&set(Vstd))
    print(*num)
    #print(" ".join(map(str,num)))
   

if __name__=="__main__":
    main()
    
        

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
import queue
def main():
    n,m,k=map(int,input().split())
    root={}
    ng={}
    for i in range(n):
        root[i]=[]
        ng[i]=[]
    for i in range(m):
        a,b=map(int,input().split())
        root[a-1].append(b-1)
        root[b-1].append(a-1)
        ng[a-1].append(b-1)
        ng[b-1].append(a-1)
    for i in range(k):
        a,b=map(int,input().split())
        ng[a-1].append(b-1)
        ng[b-1].append(a-1)
    
    Vstd=[]
    checkVst=[False]*n
    num=[0]*n
    ToVst=queue.Queue()
   
    for i in range(n):
        
        Vstd=[]
        if checkVst[i]:
            continue
        now=i
        Vstd.append(now)
        checkVst[now]=True
        

        for kouho in root[now]:
            if checkVst[kouho]:
                continue
            ToVst.put(kouho)
            checkVst[kouho]=True
            #if checkVst[kouho]!=1:
             #   ToVst.put(kouho)
              #  checkVst[kouho]=1
              
        while ToVst.empty()==False:
            now=ToVst.get()
            Vstd.append(now)
            checkVst[now]=True
           
            for kouho in root[now]:
                if checkVst[kouho]:
                    continue
                ToVst.put(kouho)
                checkVst[kouho]=True
                
        lengh=len(Vstd)
        for v in Vstd:
            num[v]=lengh-1
            num[v]-=len(set(ng[v])&set(Vstd))
            


    
    print(*num)
    #print(" ".join(map(str,num)))
   

if __name__=="__main__":
    main()
    
        

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
import queue
def main():
    n,m,k=map(int,input().split())
    root={}
    ng={}
    for i in range(n):
        root[i]=[]
        ng[i]=[]
    for i in range(m):
        a,b=map(int,input().split())
        root[a-1].append(b-1)
        root[b-1].append(a-1)
        ng[a-1].append(b-1)
        ng[b-1].append(a-1)
    for i in range(k):
        a,b=map(int,input().split())
        ng[a-1].append(b-1)
        ng[b-1].append(a-1)
    
    Vstd=[]
    checkVst=[0]*n
    num=[0]*n
    ToVst=queue.Queue()
   
    for i in range(n):
        
        Vstd=[]
        if checkVst[i]!=0:
            continue
        now=i
        Vstd.append(now)
        checkVst[now]=1
        

        for kouho in root[now]:
            if checkVst[kouho]!=1:
                ToVst.put(kouho)
                checkVst[kouho]=1
              
        while ToVst.empty()==False:
            now=ToVst.get()
            Vstd.append(now)
            checkVst[now]=1
           
            for kouho in root[now]:
                if checkVst[kouho]!=0:
                    continue
                ToVst.put(kouho)
                checkVst[kouho]=1
                
        lengh=len(Vstd)
        for v in Vstd:
            num[v]=lengh-1
            num[v]-=len(set(ng[v])&set(Vstd))
            


    
    print(*num)
    #print(" ".join(map(str,num)))
   

if __name__=="__main__":
    main()
    
        

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
import queue
def main():
    n,m,k=map(int,input().split())
    root={}
    ng={}
    for i in range(n):
        root[i]=[]
        ng[i]=[]
    for i in range(m):
        a,b=map(int,input().split())
        root[a-1].append(b-1)
        root[b-1].append(a-1)
        ng[a-1].append(b-1)
        ng[b-1].append(a-1)
    for i in range(k):
        a,b=map(int,input().split())
        ng[a-1].append(b-1)
        ng[b-1].append(a-1)
    
    Vstd=[]
    checkVst=[0]*n
    num=[0]*n
    ToVst=queue.Queue()
   
    for i in range(n):
        
        Vstd=[]
        if checkVst[i]!=0:
            continue
        now=i
        Vstd.append(now)
        checkVst[now]=1
        

        for kouho in root[now]:
            if checkVst[kouho]!=1:
                ToVst.put(kouho)
                checkVst[kouho]=1
              
        while ToVst.empty()==False:
            now=ToVst.get()
            Vstd.append(now)
            checkVst[now]=1
           
            for kouho in root[now]:
                if checkVst[kouho]!=0:
                    continue
                ToVst.put(kouho)
                checkVst[kouho]=1
                
        lengh=len(Vstd)
        for v in Vstd:
            num[v]=lengh-1
            num[v]-=len(set(ng[v])&set(Vstd))
            


    
    print(*num)
    #print(" ".join(map(str,num)))
   

if __name__=="__main__":
    main()
    
        

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
import queue
def main():
    n,m,k=map(int,input().split())
    root={}
    ng={}
    for i in range(n):
        root[i]=[]
        ng[i]=[]
    for i in range(m):
        a,b=map(int,input().split())
        root[a-1].append(b-1)
        root[b-1].append(a-1)
        ng[a-1].append(b-1)
        ng[b-1].append(a-1)
    for i in range(k):
        a,b=map(int,input().split())
        ng[a-1].append(b-1)
        ng[b-1].append(a-1)
    
    Vstd=[]
    checkVst=[0]*n
    num=[0]*n
    ToVst=queue.Queue()
    Thisturn=[0 for i in range(n)]
    for i in range(n):
        Thisturn=[0 for i in range(n)]
        Vstd=[]
        if checkVst[i]!=0:
            continue
        now=i
        Vstd.append(now)
        checkVst[now]=1
        Thisturn[now]=1

        for kouho in root[now]:
            if checkVst[kouho]!=1:
                ToVst.put(kouho)
                checkVst[kouho]=1
                Thisturn[kouho]=1
        while ToVst.empty()==False:
            now=ToVst.get()
            Vstd.append(now)
            checkVst[now]=1
            Thisturn[now]=1
            for kouho in root[now]:
                if checkVst[kouho]!=0:
                    continue
                ToVst.put(kouho)
                checkVst[kouho]=1
                Thisturn[kouho]=1
        lengh=len(Vstd)
        for v in Vstd:
            num[v]=lengh-1
            for j in ng[v]:
                if Thisturn[j]==1:
                    num[v]-=1


    
    print(*num)
    #print(" ".join(map(str,num)))
   

if __name__=="__main__":
    main()
    
        

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
import queue
def main():
    n,m,k=map(int,input().split())
    root={}
    ng={}
    friend=[[0 for i in range(n)]for i in range(n)]
    for i in range(n):
        root[i]=[]
        ng[i]=[0]*n
        ng[i][i]=1
    for i in range(m):
        a,b=map(int,input().split())
        root[a-1].append(b-1)
        root[b-1].append(a-1)
        friend[a-1][b-1]=1
        friend[b-1][a-1]=1
    for i in range(k):
        a,b=map(int,input().split())
        ng[a-1][b-1]=1
        ng[b-1][a-1]=1
    
    Vstd=[]
    checkVst=[0]*n
    num=[0]*n
    ToVst=queue.Queue()
    for i in range(n):
        Vstd=[]
        if checkVst[i]==1:
            continue
        now=i
        Vstd.append(now)
        checkVst[now]=1
        for kouho in root[now]:
            if checkVst[kouho]!=1:
                ToVst.put(kouho)
                checkVst[kouho]=1
        while ToVst.empty()==False:
            now=ToVst.get()
            Vstd.append(now)
            checkVst[now]=1
            for kouho in root[now]:
                if checkVst[kouho]==1:
                    continue
                ToVst.put(kouho)
                checkVst[kouho]=1

        l=len(Vstd)
        for x in Vstd:
            num[x]=l
            
            for y in Vstd:
                if ng[x][y]==1 or friend[x][y]==1:
                    num[x]-=1
    print(*num)
    #print(" ".join(map(str,num)))
   

if __name__=="__main__":
    main()

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
import queue
def main():
    n,m,k=map(int,input().split())
    root={}
    ng={}
    friend=[[0 for i in range(n)]for i in range(n)]
    for i in range(n):
        root[i]=[]
        ng[i]=[0]*n
        ng[i][i]=1
    for i in range(m):
        a,b=map(int,input().split())
        root[a-1].append(b-1)
        root[b-1].append(a-1)
        friend[a-1][b-1]=1
        friend[b-1][a-1]=1
    for i in range(k):
        a,b=map(int,input().split())
        ng[a-1][b-1]=1
        ng[b-1][a-1]=1
    
    Vstd=[]
    checkVst=[0]*n
    num=[0]*n
    ToVst=queue.Queue()
    for i in range(n):
        Vstd=[]
        if checkVst[i]==1:
            continue
        now=i
        Vstd.append(now)
        checkVst[now]=1
        for kouho in root[now]:
            if checkVst[kouho]!=1:
                ToVst.put(kouho)
                checkVst[kouho]=1
        while ToVst.empty()==False:
            now=ToVst.get()
            Vstd.append(now)
            checkVst[now]=1
            for kouho in root[now]:
                if checkVst[kouho]==1:
                    continue
                ToVst.put(kouho)
                checkVst[kouho]=1

        l=len(Vstd)
        for x in Vstd:
            num[x]=l
            for y in Vstd:
                if ng[x][y]==1 or friend[x][y]==1:
                    num[x]-=1
    print(*num)
    #print(" ".join(map(str,num)))
   

if __name__=="__main__":
    main()
    

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
import queue
def main():
    n,m,k=map(int,input().split())
    root={}
    ng={}
    friend={}
    for i in range(n):
        root[i]=[]
        ng[i]=[0]*n
        ng[i][i]=1
        friend[i]=[0]*n
    for i in range(m):
        a,b=map(int,input().split())
        root[a-1].append(b-1)
        root[b-1].append(a-1)
        friend[a-1][b-1]=1
        friend[b-1][a-1]=1
    for i in range(k):
        a,b=map(int,input().split())
        ng[a-1][b-1]=1
        ng[b-1][a-1]=1
    
    Vstd=[]
    checkVst=[0]*n
    num=[0]*n
    ToVst=queue.Queue()
    for i in range(n):
        Vstd=[]
        if checkVst[i]==1:
            continue
        now=i
        Vstd.append(now)
        checkVst[now]=1
        for kouho in root[now]:
            if checkVst[kouho]!=1:
                ToVst.put(kouho)
                checkVst[kouho]=1
        while ToVst.empty()==False:
            now=ToVst.get()
            Vstd.append(now)
            checkVst[now]=1
            for kouho in root[now]:
                if checkVst[kouho]==1:
                    continue
                ToVst.put(kouho)
                checkVst[kouho]=1

        l=len(Vstd)
        for x in Vstd:
            num[x]=l
            for y in Vstd:
                if ng[x][y]==1 or friend[x][y]==1:
                    num[x]-=1
    print(*num)
    #print(" ".join(map(str,num)))
   

if __name__=="__main__":
    main()
    

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
import queue
def main():
    n,m,k=map(int,input().split())
    root={}
    ng={}
    for i in range(n):
        root[i]=[]
        ng[i]=[0]*n
        ng[i][i]=1
    for i in range(m):
        a,b=map(int,input().split())
        root[a-1].append(b-1)
        root[b-1].append(a-1)
    for i in range(k):
        a,b=map(int,input().split())
        ng[a-1][b-1]=1
        ng[b-1][a-1]=1
    
    Vstd=[]
    checkVst=[0]*n
    num=[0]*n
    ToVst=queue.Queue()
    for i in range(n):
        Vstd=[]
        if checkVst[i]==1:
            continue
        now=i
        Vstd.append(now)
        checkVst[now]=1
        for kouho in root[now]:
            if checkVst[kouho]!=1:
                ToVst.put(kouho)
                checkVst[kouho]=1
        while ToVst.empty()==False:
            now=ToVst.get()
            Vstd.append(now)
            checkVst[now]=1
            for kouho in root[now]:
                if checkVst[kouho]==1:
                    continue
                ToVst.put(kouho)
                checkVst[kouho]=1

        l=len(Vstd)
        for x in Vstd:
            num[x]=l
            for y in Vstd:
                if ng[x][y]==1 or y in root[x]:
                    num[x]-=1
    print(*num)
    #print(" ".join(map(str,num)))
   

if __name__=="__main__":
    main()
    
        

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
import queue
def main():
    n,m,k=map(int,input().split())
    root={}
    ng={}
    for i in range(n):
        root[i]=[]
        ng[i]=[i]
    for i in range(m):
        a,b=map(int,input().split())
        root[a-1].append(b-1)
        root[b-1].append(a-1)
    for i in range(k):
        a,b=map(int,input().split())
        ng[a-1].append(b-1)
        ng[b-1].append(a-1)
    
    Vstd=[]
    checkVst=[0]*n
    num=[0]*n
    ToVst=queue.Queue()
    for i in range(n):
        Vstd=[]
        if checkVst[i]==1:
            continue
        now=i
        Vstd.append(now)
        checkVst[now]=1
        for kouho in root[now]:
            if checkVst[kouho]!=1:
                ToVst.put(kouho)
                checkVst[kouho]=1
        while ToVst.empty()==False:
            now=ToVst.get()
            Vstd.append(now)
            checkVst[now]=1
            for kouho in root[now]:
                if checkVst[kouho]==1:
                    continue
                ToVst.put(kouho)
                checkVst[kouho]=1

        l=len(Vstd)
        for x in Vstd:
            num[x]=l
            for y in Vstd:
                if y in ng[x] or y in root[x]:
                    num[x]-=1
    print(*num)
    #print(" ".join(map(str,num)))
   

if __name__=="__main__":
    main()
    
        

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
import queue
def main():
    n,m,k=map(int,input().split())
    root={}
    ng={}
    for i in range(n):
        root[i]=[]
        ng[i]=[i]
    for i in range(m):
        a,b=map(int,input().split())
        root[a-1].append(b-1)
        root[b-1].append(a-1)
    for i in range(k):
        a,b=map(int,input().split())
        ng[a-1].append(b-1)
        ng[b-1].append(a-1)
    
    Vstd=[]
    checkVst=[0]*n
    num=[0]*n
    ToVst=queue.Queue()
    for i in range(n):
        Vstd=[]
        if checkVst[i]==1:
            continue
        now=i
        Vstd.append(now)
        checkVst[now]=1
        for kouho in root[now]:
            if checkVst[kouho]!=1:
                ToVst.put(kouho)
                checkVst[kouho]=1
        while ToVst.empty()==False:
            now=ToVst.get()
            Vstd.append(now)
            checkVst[now]=1
            for kouho in root[now]:
                if checkVst[kouho]==1:
                    continue
                ToVst.put(kouho)
                checkVst[kouho]=1
       #         print("a")

      #  print(Vstd)
        for x in Vstd:
            num[x]=len(Vstd)
            for y in Vstd:
                if y in ng[x] or y in root[x]:
                    num[x]-=1
    print(*num)
    #print(" ".join(map(str,num)))
   

if __name__=="__main__":
    main()
    

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
import queue
def main():
    n,m,k=map(int,input().split())
    root={}
    ng={}
    for i in range(n):
        root[i]=[]
        ng[i]=[i]
    for i in range(m):
        a,b=map(int,input().split())
        root[a-1].append(b-1)
        root[b-1].append(a-1)
    for i in range(k):
        a,b=map(int,input().split())
        ng[a-1].append(b-1)
        ng[b-1].append(a-1)
    
    Vstd=[]
    checkVst=[0]*n
    num=[0]*n
    ToVst=queue.Queue()
    for i in range(n):
        Vstd=[]
        if checkVst[i]==1:
            continue
        now=i
        Vstd.append(now)
        checkVst[now]=1
        for kouho in root[now]:
            if checkVst[kouho]!=1:
                ToVst.put(kouho)
                checkVst[kouho]=1
        while ToVst.empty()==False:
            now=ToVst.get()
            Vstd.append(now)
            checkVst[now]=1
            for kouho in root[now]:
                if checkVst[kouho]==1:
                    continue
                ToVst.put(kouho)
                checkVst[kouho]=1
       #         print("a")

      #  print(Vstd)
        for x in Vstd:
            num[x]=len(Vstd)
            for y in Vstd:
                if y in ng[x] or y in root[x]:
                    num[x]-=1
    print(" ".join(map(str,num)))
    




        
        




        


if __name__=="__main__":
    main()
    
        

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Runtime Error):
import queue
import numpy
def main():
    n,m,k=map(int,input().split())
    root=numpy.array([[0]*n for i in range(n)])
    for i in range(n):
        root[i][i]=2
    for i in range(m):
        a,b=map(int,input().split())
        root[a-1][b-1]=1
        root[b-1][a-1]=1
    for i in range(k):
        a,b=map(int,input().split())
        root[a-1][b-1]=-100
        root[b-1][a-1]=-100
    toVis=queue.Queue()
    Visted=[]
    checkOK=numpy.zeros(n)#その点に関しての友達候補つくり済みかどうか
    OK={}#友達候補リスト
    checkVis=numpy.zeros(n)#訪れたか確認するためのリスト
    checkVinit=numpy.zeros(n)#初期化のためのりすと
    for i in range(n):
        if checkOK[i]==5:
            continue
        checkVis=checkVinit
        Visted=[i]
        checkVis[i]=5
        toVis=queue.Queue()
        
        for j in range(len(root[i])):
            nex=root[i][j]
            if checkVis[j]!=5 and nex==1:
                toVis.put(j)

        while toVis.empty()==False:
        
            now=toVis.get()

            if checkVis[now]==5:
                continue

            Visted.append(now)
            checkVis[now]=5
            for j in range(n):#len(rooot[now]
                nex=root[now][j]
                if nex==1 and checkVis[j]!=5:
                    toVis.put(j)
    
        for j in Visted:
            OK[j]=Visted
            checkOK[j]=5
    ans=[]
    for i in range(n):
        num=0
      """  for value in OK[i]:
            if root[i][value]==0:
                num+=1"""
        ans.append(num)
    print(" ".join(map(str,ans)))
if __name__=="__main__":
    main()


Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Runtime Error):
import queue
import numpy
def main():
    n,m,k=map(int,input().split())
    root=numpy.array([[0]*n for i in range(n)])
    for i in range(n):
        root[i][i]=2
    for i in range(m):
        a,b=map(int,input().split())
        root[a-1][b-1]=1
        root[b-1][a-1]=1
    for i in range(k):
        a,b=map(int,input().split())
        root[a-1][b-1]=-100
        root[b-1][a-1]=-100
    toVis=queue.Queue()
    Visted=[]
    checkOK=numpy.zeros(n)#その点に関しての友達候補つくり済みかどうか
    OK={}#友達候補リスト
    checkVis=numpy.zeros(n)#訪れたか確認するためのリスト
    checkVinit=numpy.zeros(n)#初期化のためのりすと
    for i in range(n):
        if checkOK[i]==5:
            continue
        checkVis=checkVinit
        Visted=[i]
        checkVis[i]=5
        toVis=queue.Queue()
        
        for j in range(len(root[i])):
            nex=root[i][j]
            if checkVis[j]!=5 and nex==1:
                toVis.put(j)

        while toVis.empty()==False:
        
            now=toVis.get()

            if checkVis[now]==5:
                continue

            Visted.append(now)
            checkVis[now]=5
            for j in range(n):#len(rooot[now]
                nex=root[now][j]
                if nex==1 and checkVis[j]!=5:
                    toVis.put(j)
    
        for j in Visted:
            OK[j]=Visted
            checkOK[j]=5
    ans=[]
    for i in range(n):
        num=0
      """  for value in OK[i]:
            if root[i][value]==0:
                num+=1
        ans.append(num)"""
    print(" ".join(map(str,ans)))
if __name__=="__main__":
    main()


Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
import queue
import numpy
def main():
    n,m,k=map(int,input().split())
    root=numpy.array([[0]*n for i in range(n)])
    for i in range(n):
        root[i][i]=2
    for i in range(m):
        a,b=map(int,input().split())
        root[a-1][b-1]=1
        root[b-1][a-1]=1
    for i in range(k):
        a,b=map(int,input().split())
        root[a-1][b-1]=-100
        root[b-1][a-1]=-100
    toVis=queue.Queue()
    Visted=[]
    checkOK=numpy.zeros(n)#その点に関しての友達候補つくり済みかどうか
    OK={}#友達候補リスト
    checkVis=numpy.zeros(n)#訪れたか確認するためのリスト
    checkVinit=numpy.zeros(n)#初期化のためのりすと
    for i in range(n):
        if checkOK[i]==5:
            continue
        checkVis=checkVinit
        Visted=[i]
        checkVis[i]=5
        toVis=queue.Queue()
        
        for j in range(len(root[i])):
            nex=root[i][j]
            if checkVis[j]!=5 and nex==1:
                toVis.put(j)

        while toVis.empty()==False:
        
            now=toVis.get()

            if checkVis[now]==5:
                continue

            Visted.append(now)
            checkVis[now]=5
            for j in range(n):#len(rooot[now]
                nex=root[now][j]
                if nex==1 and checkVis[j]!=5:
                    toVis.put(j)
    
        for j in Visted:
            OK[j]=Visted
            checkOK[j]=5
    ans=[]
    for i in range(n):
        num=0
        for value in OK[i]:
            if root[i][value]==0:
                num+=1
        ans.append(num)
    print(" ".join(map(str,ans)))
if __name__=="__main__":
    main()


Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Runtime Error):
import queue

import numpy
def main():
    n,m,k=map(int,input().split())
    root=numpy.array([numpy.zeros(n) for i in range(n)])
    for i in range(n):
        root[i][i]=2
    for i in range(m):
        a,b=map(int,input().split())
        root[a-1][b-1]=1
        root[b-1][a-1]=1
    for i in range(k):
        a,b=map(int,input().split())
        root[a-1][b-1]=-100
        root[b-1][a-1]=-100
    toVis=queue.Queue()
    Visted=[]
    checkOK=numpy.zeros(n)#その点に関しての友達候補つくり済みかどうか
    OK={}#友達候補リスト
    checkVis=numpy.zeros(n)#訪れたか確認するためのリスト
    checkVinit=numpy.zeros(n)#初期化のためのりすと
    for i in range(n):
        if checkOK[i]==5:#既にもうお友達候補探索済みならしない
            continue
       # print(i)
        checkVis=checkVinit#訪れたかリストの初期化
        Visted=[i]#iは現在地だ
        checkVis[i]=5#当然訪れている
        toVis=queue.Queue()#訪れるべき点のキュー
        
        for j in range(len(root[i])):#iの列を見て、
            nex=root[i][j]          #i->jの値
            if checkVis[j]!=5 and nex==1:#5は既に訪れている 1は不通
                toVis.put(j)#でなけれな訪れるべき場所なので追加

        while toVis.empty()==False:
        
            now=toVis.get()#キューからとって訪れる

            if checkVis[now]==5:##そこが訪れ済みならスルー（ほんらいこれいらないと思う）
                continue

            Visted.append(now)#訪れたリストに追加
            checkVis[now]=5#チェック用にも追加
            for j in range(n):#len(root[now]
                nex=root[now][j]
                if nex==1 and checkVis[j]!=5:#次に訪れることのできる点をキューに入れる
                    toVis.put(j)
    
        for j in Visted:#訪れたリストにある点は互いに行き来ができるはず
            OK[j]=Visted#各点の訪れられる点リストはvistedで共通
            checkOK[j]=5#ｊはもうやらなくていいのでチェック
    
    ans=[]
    for i in range(n):
        num=0
        for value in OK[i]:
            if root[i][value]==0:#各行ける点からお友達じゃないかつブロックじゃないヒトをピックアップ
                num+=1
        ans.append(num)
    print(" ".join(map(str,ans)))
if __name__=="__main__":
    main()

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Runtime Error):
import queue
import sys
import numpy
input = sys.stdin.readline

def main():
    n,m,k=map(int,input().split())
    root=numpy.array([numpy.zeros(n) for i in range(n)])
    for i in range(n):
        root[i][i]=2
    for i in range(m):
        a,b=map(int,input().split())
        root[a-1][b-1]=1
        root[b-1][a-1]=1
    for i in range(k):
        a,b=map(int,input().split())
        root[a-1][b-1]=-100
        root[b-1][a-1]=-100
    toVis=queue.Queue()
    Visted=[]
    checkOK=numpy.zeros(n)#その点に関しての友達候補つくり済みかどうか
    OK={}#友達候補リスト
    checkVis=numpy.zeros(n)#訪れたか確認するためのリスト
    checkVinit=numpy.zeros(n)#初期化のためのりすと
    for i in range(n):
        if checkOK[i]==5:#既にもうお友達候補探索済みならしない
            continue
       # print(i)
        checkVis=checkVinit#訪れたかリストの初期化
        Visted=[i]#iは現在地だ
        checkVis[i]=5#当然訪れている
        toVis=queue.Queue()#訪れるべき点のキュー
        
        for j in range(len(root[i])):#iの列を見て、
            nex=root[i][j]          #i->jの値
            if checkVis[j]!=5 and nex==1:#5は既に訪れている 1は不通
                toVis.put(j)#でなけれな訪れるべき場所なので追加

        while toVis.empty()==False:
        
            now=toVis.get()#キューからとって訪れる

            if checkVis[now]==5:##そこが訪れ済みならスルー（ほんらいこれいらないと思う）
                continue

            Visted.append(now)#訪れたリストに追加
            checkVis[now]=5#チェック用にも追加
            for j in range(n):#len(root[now]
                nex=root[now][j]
                if nex==1 and checkVis[j]!=5:#次に訪れることのできる点をキューに入れる
                    toVis.put(j)
    
        for j in Visted:#訪れたリストにある点は互いに行き来ができるはず
            OK[j]=Visted#各点の訪れられる点リストはvistedで共通
            checkOK[j]=5#ｊはもうやらなくていいのでチェック
    
    ans=[]
    for i in range(n):
        num=0
        for value in OK[i]:
            if root[i][value]==0:#各行ける点からお友達じゃないかつブロックじゃないヒトをピックアップ
                num+=1
        ans.append(num)
    print(" ".join(map(str,ans)))
if __name__=="__main__":
    main()

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Runtime Error):
import queue
import sys
import numpy
input = sys.stdin.readline

def main():
    n,m,k=map(int,input().split())
    root=numpy.array([numpy.zeros(n) for i in range(n)])
    for i in range(n):
        root[i][i]=2
    for i in range(m):
        a,b=map(int,input().split())
        root[a-1][b-1]=1
        root[b-1][a-1]=1
    for i in range(k):
        a,b=map(int,input().split())
        root[a-1][b-1]=-100
        root[b-1][a-1]=-100
    toVis=queue.Queue()
    Visted=[]
    checkOK=numpy.zeros(n)#その点に関しての友達候補つくり済みかどうか
    OK={}#友達候補リスト
    checkVis=numpy.zeros(n)#訪れたか確認するためのリスト
    checkVinit=numpy.zeros(n)#初期化のためのりすと
    for i in range(n):
        if checkOK[i]==5:#既にもうお友達候補探索済みならしない
            continue
        print(i)
        checkVis=checkVinit#訪れたかリストの初期化
        Visted=[i]#iは現在地だ
        checkVis[i]=5#当然訪れている
        toVis=queue.Queue()#訪れるべき点のキュー
        
        for j in range(len(root[i])):#iの列を見て、
            nex=root[i][j]          #i->jの値
            if checkVis[j]!=5 and nex==1:#5は既に訪れている 1は不通
                toVis.put(j)#でなけれな訪れるべき場所なので追加

        while toVis.empty()==False:
        
            now=toVis.get()#キューからとって訪れる

            if checkVis[now]==5:##そこが訪れ済みならスルー（ほんらいこれいらないと思う）
                continue

            Visted.append(now)#訪れたリストに追加
            checkVis[now]=5#チェック用にも追加
            for j in range(n):#len(root[now]
                nex=root[now][j]
                if nex==1 and checkVis[j]!=5:#次に訪れることのできる点をキューに入れる
                    toVis.put(j)
    
        for j in Visted:#訪れたリストにある点は互いに行き来ができるはず
            OK[j]=Visted#各点の訪れられる点リストはvistedで共通
            checkOK[j]=5#ｊはもうやらなくていいのでチェック
    
    ans=[]
    for i in range(n):
        num=0
        for value in OK[i]:
            if root[i][value]==0:#各行ける点からお友達じゃないかつブロックじゃないヒトをピックアップ
                num+=1
        ans.append(num)
    print(" ".join(map(str,ans)))
if __name__=="__main__":
    main()

    
        

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Runtime Error):
import queue
import numpy
def main():
    n,m,k=map(int,input().split())
    root=numpy.array([numpy.zeros(n) for i in range(n)])
    for i in range(n):
        root[i][i]=2
    for i in range(m):
        a,b=map(int,input().split())
        root[a-1][b-1]=1
        root[b-1][a-1]=1
    for i in range(k):
        a,b=map(int,input().split())
        root[a-1][b-1]=-100
        root[b-1][a-1]=-100
    toVis=queue.Queue()
    Visted=[]
    checkOK=numpy.zeros(n)#その点に関しての友達候補つくり済みかどうか
    OK={}#友達候補リスト
    checkVis=numpy.zeros(n)#訪れたか確認するためのリスト
    checkVinit=numpy.zeros(n)#初期化のためのりすと
    for i in range(n):
        if checkOK[i]==5:#既にもうお友達候補探索済みならしない
            continue
        print(i)
        checkVis=checkVinit#訪れたかリストの初期化
        Visted=[i]#iは現在地だ
        checkVis[i]=5#当然訪れている
        toVis=queue.Queue()#訪れるべき点のキュー
        
        for j in range(len(root[i])):#iの列を見て、
            nex=root[i][j]          #i->jの値
            if checkVis[j]!=5 and nex==1:#5は既に訪れている 1は不通
                toVis.put(j)#でなけれな訪れるべき場所なので追加

        while toVis.empty()==False:
        
            now=toVis.get()#キューからとって訪れる

            if checkVis[now]==5:##そこが訪れ済みならスルー（ほんらいこれいらないと思う）
                continue

            Visted.append(now)#訪れたリストに追加
            checkVis[now]=5#チェック用にも追加
            for j in range(n):#len(root[now]
                nex=root[now][j]
                if nex==1 and checkVis[j]!=5:#次に訪れることのできる点をキューに入れる
                    toVis.put(j)
    
        for j in Visted:#訪れたリストにある点は互いに行き来ができるはず
            OK[j]=Visted#各点の訪れられる点リストはvistedで共通
            checkOK[j]=5#ｊはもうやらなくていいのでチェック
    print(1," ",1," ",1)
    """
    ans=[]
    for i in range(n):
        num=0
        for value in OK[i]:
            if root[i][value]==0:#各行ける点からお友達じゃないかつブロックじゃないヒトをピックアップ
                num+=1
        ans.append(num)
    print(" ".join(map(str,ans)))"""
if __name__=="__main__":
    main()


Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Runtime Error):
import queue
import numpy
def main():
    n,m,k=map(int,input().split())
    root=numpy.array([numpy.zeros(n) for i in range(n)])
    for i in range(n):
        root[i][i]=2
    for i in range(m):
        a,b=map(int,input().split())
        root[a-1][b-1]=1
        root[b-1][a-1]=1
    for i in range(k):
        a,b=map(int,input().split())
        root[a-1][b-1]=-100
        root[b-1][a-1]=-100
    toVis=queue.Queue()
    Visted=[]
    checkOK=numpy.zeros(n)#その点に関しての友達候補つくり済みかどうか
    OK={}#友達候補リスト
    checkVis=numpy.zeros(n)#訪れたか確認するためのリスト
    checkVinit=numpy.zeros(n)#初期化のためのりすと
    for i in range(n):
        if checkOK[i]==5:#既にもうお友達候補探索済みならしない
            continue
        print(i)
        checkVis=checkVinit#訪れたかリストの初期化
        Visted=[i]#iは現在地だ
        checkVis[i]=5#当然訪れている
        toVis=queue.Queue()#訪れるべき点のキュー
        
        for j in range(len(root[i])):#iの列を見て、
            nex=root[i][j]          #i->jの値
            if checkVis[j]!=5 and nex==1:#5は既に訪れている 1は不通
                toVis.put(j)#でなけれな訪れるべき場所なので追加

        while toVis.empty()==False:
        
            now=toVis.get()#キューからとって訪れる

            if checkVis[now]==5:##そこが訪れ済みならスルー（ほんらいこれいらないと思う）
                continue

            Visted.append(now)#訪れたリストに追加
            checkVis[now]=5#チェック用にも追加
            for j in range(n):#len(root[now]
                nex=root[now][j]
                if nex==1 and checkVis[j]!=5:#次に訪れることのできる点をキューに入れる
                    toVis.put(j)
    
        for j in Visted:#訪れたリストにある点は互いに行き来ができるはず
            OK[j]=Visted#各点の訪れられる点リストはvistedで共通
            checkOK[j]=5#ｊはもうやらなくていいのでチェック
    print(1 1 1 1 1)
    """
    ans=[]
    for i in range(n):
        num=0
        for value in OK[i]:
            if root[i][value]==0:#各行ける点からお友達じゃないかつブロックじゃないヒトをピックアップ
                num+=1
        ans.append(num)
    print(" ".join(map(str,ans)))"""
if __name__=="__main__":
    main()


Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
import queue
import numpy
def main():
    n,m,k=map(int,input().split())
    root=numpy.array([[0]*n for i in range(n)])
    for i in range(n):
        root[i][i]=2
    for i in range(m):
        a,b=map(int,input().split())
        root[a-1][b-1]=1
        root[b-1][a-1]=1
    for i in range(k):
        a,b=map(int,input().split())
        root[a-1][b-1]=-100
        root[b-1][a-1]=-100
    toVis=queue.Queue()
    Visted=[]
    checkOK=numpy.zeros(n)#その点に関しての友達候補つくり済みかどうか
    OK={}#友達候補リスト
    checkVis=numpy.zeros(n)#訪れたか確認するためのリスト
    checkVinit=numpy.zeros(n)#初期化のためのりすと
    for i in range(n):
        if checkOK[i]==5:
            continue
        checkVis=checkVinit
        Visted=[i]
        checkVis[i]=5
        toVis=queue.Queue()
        
        for j in range(len(root[i])):
            nex=root[i][j]
            if checkVis[j]!=5 and nex==1:
                toVis.put(j)

        while toVis.empty()==False:
        
            now=toVis.get()

            if checkVis[now]==5:
                continue

            Visted.append(now)
            checkVis[now]=5
            for j in range(n):#len(rooot[now]
                nex=root[now][j]
                if nex==1 and checkVis[j]!=5:
                    toVis.put(j)
    
        for j in Visted:
            OK[j]=Visted
            checkOK[j]=5
    ans=[]
    for i in range(n):
        num=0
        for value in OK[i]:
            if root[i][value]==0:
                num+=1
        ans.append(num)
    print(" ".join(map(str,ans)))
if __name__=="__main__":
    main()

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
import queue
def main():
    n,m,k=map(int,input().split())
    root=[[0]*n for i in range(n)]
    for i in range(n):
        root[i][i]=2
    for i in range(m):
        a,b=map(int,input().split())
        root[a-1][b-1]=1
        root[b-1][a-1]=1
    for i in range(k):
        a,b=map(int,input().split())
        root[a-1][b-1]=-float("inf")
        root[b-1][a-1]=-float("inf")
    toVis=queue.Queue()
    Visted=[]
    
    checkOK=[0]*n
    OK={}
    checkVis=[0]*n
    checkVinit=[0]*n
    for i in range(n):
        if checkOK[i]==5:
            continue
        checkVis=checkVinit
        Visted=[i]
        checkVis[i]=5
        toVis=queue.Queue()
        
        for j in range(len(root[i])):
            nex=root[i][j]
            if checkVis[j]!=5 and nex==1:
                toVis.put(j)

        while toVis.empty()==False:
        
            now=toVis.get()

            if checkVis[now]==5:
                continue

            Visted.append(now)
            checkVis[now]=5
            for j in range(n):#len(rooot[now]
                nex=root[now][j]
                if nex==1 and checkVis[j]!=5:
                    toVis.put(j)
    
        for j in Visted:
            OK[j]=Visted
            checkOK[j]=5
    ans=[]
    for i in range(n):
        num=0
        for value in OK[i]:
            if root[i][value]==0:
                num+=1
        ans.append(num)
    print(" ".join(map(str,ans)))
if __name__=="__main__":
    main()

    

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
import queue
def main():
    n,m,k=map(int,input().split())
    root=[[0]*n for i in range(n)]
    for i in range(n):
        root[i][i]=2
    #print(root)
    for i in range(m):
        a,b=map(int,input().split())
    # print("berfot",root[a-1][b-1])
        root[a-1][b-1]=1
        root[b-1][a-1]=1
    #  print("after",root[a-1][b-1])
    for i in range(k):
        a,b=map(int,input().split())
    #   print(a,b)
        root[a-1][b-1]=-float("inf")
        root[b-1][a-1]=-float("inf")
    #print(root)
    toVis=queue.Queue()
    Visted=[]
    #checkVinit=[0 for i in range(n)]
    
    checkOK=[0]*n
    OK={}
    checkVis=[0]*n
    checkVinit=[0]*n
    for i in range(n):
        if checkOK[i]==5:
            continue
        checkVis=checkVinit
        Visted=[i]
        checkVis[i]=5


        #if checkOK[i]==5:
         #   continue
        toVis=queue.Queue()
        
        for j in range(len(root[i])):
            nex=root[i][j]
        # if j not in Visted and nex==1:
            if checkVis[j]!=5 and nex==1:
                toVis.put(j)

        while toVis.empty()==False:
        
            now=toVis.get()
            #if now in Visted:
            if checkVis[now]==5:
                continue
        #   print("now :" ,now)
            Visted.append(now)
            checkVis[now]=5
            for j in range(n):#len(rooot[now]
                nex=root[now][j]
                #if nex==1 and j not in Visted:
                if nex==1 and checkVis[j]!=5:
        #          print("apend",nex)
                    toVis.put(j)
    
        for j in Visted:
            OK[j]=Visted
            checkOK[j]=5
    #print(OK)
    ans=[]
    for i in range(n):
        num=0
        for value in OK[i]:
            if root[i][value]==0:
                num+=1
        ans.append(num)
    print(" ".join(map(str,ans)))
if __name__=="__main__":
    main()

    
        

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
import queue
def main():
    n,m,k=map(int,input().split())
    root=[[0]*n for i in range(n)]
    for i in range(n):
        root[i][i]=2
    #print(root)
    for i in range(m):
        a,b=map(int,input().split())
    # print("berfot",root[a-1][b-1])
        root[a-1][b-1]=1
        root[b-1][a-1]=1
    #  print("after",root[a-1][b-1])
    for i in range(k):
        a,b=map(int,input().split())
    #   print(a,b)
        root[a-1][b-1]=-float("inf")
        root[b-1][a-1]=-float("inf")
    #print(root)
    toVis=queue.Queue()
    Visted=[]
    #checkVinit=[0 for i in range(n)]
    
    checkOK=[0]*n
    OK={}
    checkVis=[0]*n
    checkVinit=[0]*n
    for i in range(n):
        checkVis=checkVinit
        Visted=[i]
        checkVis[i]=5


        if checkOK[i]==5:
            continue
        toVis=queue.Queue()
        
        for j in range(len(root[i])):
            nex=root[i][j]
        # if j not in Visted and nex==1:
            if checkVis[j]!=5 and nex==1:
                toVis.put(j)

        while toVis.empty()==False:
        
            now=toVis.get()
            #if now in Visted:
            if checkVis[now]==5:
                continue
        #   print("now :" ,now)
            Visted.append(now)
            checkVis[now]=5
            for j in range(n):#len(rooot[now]
                nex=root[now][j]
                #if nex==1 and j not in Visted:
                if nex==1 and checkVis[j]!=5:
        #          print("apend",nex)
                    toVis.put(j)
    
        for j in Visted:
            OK[j]=Visted
            checkOK[j]=5
    #print(OK)
    ans=[]
    for i in range(n):
        num=0
        for value in OK[i]:
            if root[i][value]==0:
                num+=1
        ans.append(num)
    print(" ".join(map(str,ans)))
if __name__=="__main__":
    main()

    
        

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
import queue
def main():
    n,m,k=map(int,input().split())
    root=[[0]*n for i in range(n)]
    for i in range(n):
        root[i][i]=2
    #print(root)
    for i in range(m):
        a,b=map(int,input().split())
    # print("berfot",root[a-1][b-1])
        root[a-1][b-1]=1
        root[b-1][a-1]=1
    #  print("after",root[a-1][b-1])
    for i in range(k):
        a,b=map(int,input().split())
    #   print(a,b)
        root[a-1][b-1]=-float("inf")
        root[b-1][a-1]=-float("inf")
    #print(root)
    toVis=queue.Queue()
    Visted=[]
    checkOK=[0 for i in range(n)]
    OK={}
    checkVis=[0 for i in range(n)]
    checkVinit=checkVis
    for i in range(n):
        checkVis=checkVinit
        Visted=[i]
        checkVis[i]=5


        if checkOK[i]==5:
            continue
        toVis=queue.Queue()
        
        for j in range(len(root[i])):
            nex=root[i][j]
        # if j not in Visted and nex==1:
            if checkVis[j]!=5 and nex==1:
                toVis.put(j)

        while toVis.empty()==False:
        
            now=toVis.get()
            #if now in Visted:
            if checkVis[now]==5:
                continue
        #   print("now :" ,now)
            Visted.append(now)
            checkVis[now]=5
            for j in range(n):#len(rooot[now]
                nex=root[now][j]
                #if nex==1 and j not in Visted:
                if nex==1 and checkVis[j]!=5:
        #          print("apend",nex)
                    toVis.put(j)
    
        for j in Visted:
            OK[j]=Visted
            checkOK[j]=5
    #print(OK)
    ans=[]
    for i in range(n):
        num=0
        for value in OK[i]:
            if root[i][value]==0:
                num+=1
        ans.append(num)
    print(" ".join(map(str,ans)))
if __name__=="__main__":
    main()

    

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
import queue
n,m,k=map(int,input().split())
root=[[0]*n for i in range(n)]
for i in range(n):
    root[i][i]=2
#print(root)
for i in range(m):
    a,b=map(int,input().split())
   # print("berfot",root[a-1][b-1])
    root[a-1][b-1]=1
    root[b-1][a-1]=1
  #  print("after",root[a-1][b-1])
for i in range(k):
    a,b=map(int,input().split())
 #   print(a,b)
    root[a-1][b-1]=-float("inf")
    root[b-1][a-1]=-float("inf")
#print(root)
toVis=queue.Queue()
Visted=[]
checkOK=[0 for i in range(n)]
OK={}
checkVis=[0 for i in range(n)]
checkVinit=checkVis
for i in range(n):
    checkVis=checkVinit
    Visted=[i]
    checkVis[i]=5


    if checkOK[i]==5:
        continue
    toVis=queue.Queue()
    
    for j in range(len(root[i])):
        nex=root[i][j]
       # if j not in Visted and nex==1:
        if checkVis[j]!=5 and nex==1:
            toVis.put(j)

    while toVis.empty()==False:
    
        now=toVis.get()
        #if now in Visted:
        if checkVis[now]==5:
            continue
     #   print("now :" ,now)
        Visted.append(now)
        checkVis[now]=5
        for j in range(n):#len(rooot[now]
            nex=root[now][j]
            #if nex==1 and j not in Visted:
            if nex==1 and checkVis[j]!=5:
      #          print("apend",nex)
                toVis.put(j)
   
    for j in Visted:
        OK[j]=Visted
        checkOK[j]=5
#print(OK)
ans=[]
for i in range(n):
    num=0
    for value in OK[i]:
        if root[i][value]==0:
            num+=1
    ans.append(num)
print(" ".join(map(str,ans)))


    

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
import queue
n,m,k=map(int,input().split())
root=[[0]*n for i in range(n)]
for i in range(n):
    root[i][i]=2
#print(root)
for i in range(m):
    a,b=map(int,input().split())
   # print("berfot",root[a-1][b-1])
    root[a-1][b-1]=1
    root[b-1][a-1]=1
  #  print("after",root[a-1][b-1])
for i in range(k):
    a,b=map(int,input().split())
 #   print(a,b)
    root[a-1][b-1]=-float("inf")
    root[b-1][a-1]=-float("inf")
#print(root)
toVis=queue.Queue()
Visted=[]
OK={}
checkVis=[0 for i in range(n)]
checkVinit=checkVis
for i in range(n):
    checkVis=checkVinit
    Visted=[i]
    checkVis[i]=5


    if i in OK.keys():
        continue
    toVis=queue.Queue()
    
    for j in range(len(root[i])):
        nex=root[i][j]
       # if j not in Visted and nex==1:
        if checkVis[j]!=5 and nex==1:
            toVis.put(j)

    while toVis.empty()==False:
    
        now=toVis.get()
        #if now in Visted:
        if checkVis[now]==5:
            continue
     #   print("now :" ,now)
        Visted.append(now)
        checkVis[now]=5
        for j in range(n):#len(rooot[now]
            nex=root[now][j]
            #if nex==1 and j not in Visted:
            if nex==1 and checkVis[j]!=5:
      #          print("apend",nex)
                toVis.put(j)
   
    for j in Visted:
        OK[j]=Visted
#print(OK)
ans=[]
for i in range(n):
    num=0
    for value in OK[i]:
        if root[i][value]==0:
            num+=1
    ans.append(num)
print(" ".join(map(str,ans)))


    
      

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
import queue
n,m,k=map(int,input().split())
root=[[0]*n for i in range(n)]
for i in range(n):
    root[i][i]=2
#print(root)
for i in range(m):
    a,b=map(int,input().split())
   # print("berfot",root[a-1][b-1])
    root[a-1][b-1]=1
    root[b-1][a-1]=1
  #  print("after",root[a-1][b-1])
for i in range(k):
    a,b=map(int,input().split())
 #   print(a,b)
    root[a-1][b-1]=-float("inf")
    root[b-1][a-1]=-float("inf")
#print(root)
toVis=queue.Queue()
Visted=[]
OK={}
checkVis=[0 for i in range(n)]
checkVinit=checkVis
for i in range(n):
    checkVis=checkVinit
    Visted=[i]
    checkVis[i]=5


    if i in OK.keys():
        continue
    toVis=queue.Queue()
    
    for j in range(len(root[i])):
        nex=root[i][j]
       # if j not in Visted and nex==1:
        if checkVis[j]!=5 and nex==1:
            toVis.put(j)

    while toVis.empty()==False:
    
        now=toVis.get()
        #if now in Visted:
        if checkVis[now]==5:
            continue
     #   print("now :" ,now)
        Visted.append(now)
        checkVis[now]=5
        for j in range(len(root[now])):
            nex=root[now][j]
            #if nex==1 and j not in Visted:
            if nex==1 and checkVis[j]!=5:
      #          print("apend",nex)
                toVis.put(j)
   
    for j in range(len(Visted)):
        OK[Visted[j]]=Visted
#print(OK)
ans=[]
for i in range(n):
    num=0
    for value in OK[i]:
        if root[i][value]==0:
            num+=1
    ans.append(num)
print(" ".join(map(str,ans)))



Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)

Buggy python submission (verdict: Time Limit Exceeded):
import queue
n,m,k=map(int,input().split())
root=[[0]*n for i in range(n)]
for i in range(n):
    root[i][i]=2
#print(root)
for i in range(m):
    a,b=map(int,input().split())
   # print("berfot",root[a-1][b-1])
    root[a-1][b-1]=1
    root[b-1][a-1]=1
  #  print("after",root[a-1][b-1])
for i in range(k):
    a,b=map(int,input().split())
 #   print(a,b)
    root[a-1][b-1]=-float("inf")
    root[b-1][a-1]=-float("inf")
#print(root)
toVis=queue.Queue()
Visted=[]
OK={}

for i in range(n):
    Visted=[i]

    if i in OK.keys():
        continue
    toVis=queue.Queue()
    
    for j in range(len(root[i])):
        nex=root[i][j]
        if j not in Visted and nex==1:
            toVis.put(j)

    while toVis.empty()==False:
    
        now=toVis.get()
        if now in Visted:
            continue
     #   print("now :" ,now)
        Visted.append(now)
        for j in range(len(root[now])):
            nex=root[now][j]
            if nex==1 and j not in Visted:
      #          print("apend",nex)
                toVis.put(j)
   
    for j in range(len(Visted)):
        OK[Visted[j]]=Visted
#print(OK)
ans=[]
for i in range(n):
    num=0
    for value in OK[i]:
        if root[i][value]==0:
            num+=1
    ans.append(num)
print(" ".join(map(str,ans)))


    
        

Fixed submission:
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())
uf=UnionFind(n)
block={}
for i in range(n):
    block[i]=[i]
for i in range(m):
    a,b=map(int,input().split())
    uf.union(a-1,b-1)
    block[a-1].append(b-1)
    block[b-1].append(a-1)
    
for i in range(k):
    a,b=map(int,input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)
ans=[]
#print(block)
for i in range(n):
    res=uf.size(i)
 #   print(res)
    for value in block[i]:
        if uf.same(value,i):
            res-=1
    ans.append(res)
print(*ans)