### BUGGY CODE ###

def dijkstra(s,n,w,cost):
    #始点sから各頂点への最短距離
    #n:頂点数,　w:辺の数, cost[u][v] : 辺uvのコスト(存在しないときはinf)
    d=[float("inf")]*n #各頂点への距離
    used=[False]*n
    d[s]=0
    
    while True:
        v=-1
        #まだ使われてない頂点の中から最小の距離のものを探す
        for i in range(n):
            if (not used[i]) and (v==-1): #その頂点が使われたかチェック
                v=i			            #まだなら仮確定
            elif (not used[i]) and d[i]<d[v]: #より距離が近いのがあればそちらから
                v=i
        if v==-1:
             break
        used[v]=True
               
        for j in range(n):
            d[j]=min(d[j],d[v]+cost[v][j])
    return d

################################
def main():
    n,m,k=map(int,input().split()) #n:頂点数　m:辺の数 k:ブロック関係の数

    cost=[[float("inf") for i in range(n)] for i in range(n)] 
    #cost[u][v] : 辺uvのコスト(存在しないときはinf この場合は10**10)
    block=[[None for i in range(n)] for i in range(n)] 
    for i in range(m): #友人関係
        x,y=map(int,input().split())
        cost[x-1][y-1]=1
        block[x-1][y-1]=True
        cost[y-1][x-1]=1
        block[y-1][x-1]=True

    for i in range(k): #ブロック関係
        x,y=map(int,input().split())
        block[x-1][y-1]=False
        block[y-1][x-1]=False

    ans=[]
    for i in range(n):
        dijk=dijkstra(i,n,m,cost)
        for x,j in enumerate(block[i]): #blockから各リスト取り出す
            if j==False or j==True:
                dijk[x]=0
        cnt=0
        for i in dijk:
            if i>0 and i!=float('inf'):
                cnt+=1
        ans.append(cnt)
    print(*ans)

if __name__ =="__main__":
    main()

### FIXED CODE ###

class UnionFind():
    def __init__(self, n):
        self.n=n
        self.parents=[-1]*n #各要素の親要素の番号を格納するリスト

    def find(self, x): #要素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が属するグループと要素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): #要素xが属するグループのサイズ（要素数）を返す
        return -self.parents[self.find(x)]

    def same(self,x,y): #要素x, yが同じグループに属するかどうかを返す
        return self.find(x)==self.find(y)

    def members(self,x): #要素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())

#print(list(uf.all_group_members().values())) #グループ一覧を表示

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

uf=UnionFind(n)
cnt=[0]*n

for _ in range(m):
    x,y=map(int,input().split())
    uf.union(x-1,y-1)
    cnt[x-1]+=1
    cnt[y-1]+=1
for _ in range(k):
    x,y=map(int,input().split())
    if uf.same(x-1,y-1):
        cnt[x-1]+=1
        cnt[y-1]+=1
    
for i in range(n):
    print(uf.size(i)-cnt[i]-1,end=" ")