Problem:
Score : 400 points

Problem Statement

An SNS has N users - User 1, User 2, \cdots, User N.

Between these N users, there are some relationships - M friendships and K blockships.

For each i = 1, 2, \cdots, M, there is a bidirectional friendship between User A_i and User B_i.

For each i = 1, 2, \cdots, K, there is a bidirectional blockship between User C_i and User D_i.

We define User a to be a friend candidate for User b when all of the following four conditions are satisfied:

a \neq b.

There is not a friendship between User a and User b.

There is not a blockship between User a and User b.

There exists a sequence c_0, c_1, c_2, \cdots, c_L consisting of integers between 1 and N (inclusive) such that c_0 = a, c_L = b, and there is a friendship between User c_i and c_{i+1} for each i = 0, 1, \cdots, L - 1.

For each user i = 1, 2, ... N, how many friend candidates does it have?

Constraints

All values in input are integers.

2 ≤ N ≤ 10^5

0 \leq M \leq 10^5

0 \leq K \leq 10^5

1 \leq A_i, B_i \leq N

A_i \neq B_i

1 \leq C_i, D_i \leq N

C_i \neq D_i

(A_i, B_i) \neq (A_j, B_j) (i \neq j)

(A_i, B_i) \neq (B_j, A_j)

(C_i, D_i) \neq (C_j, D_j) (i \neq j)

(C_i, D_i) \neq (D_j, C_j)

(A_i, B_i) \neq (C_j, D_j)

(A_i, B_i) \neq (D_j, C_j)

Input

Input is given from Standard Input in the following format:

N M K
A_1 B_1
\vdots
A_M B_M
C_1 D_1
\vdots
C_K D_K

Output

Print the answers in order, with space in between.

Sample Input 1

4 4 1
2 1
1 3
3 2
3 4
4 1

Sample Output 1

0 1 0 1

There is a friendship between User 2 and 3, and between 3 and 4. Also, there is no friendship or blockship between User 2 and 4. Thus, User 4 is a friend candidate for User 2.

However, neither User 1 or 3 is a friend candidate for User 2, so User 2 has one friend candidate.

Sample Input 2

5 10 0
1 2
1 3
1 4
1 5
3 2
2 4
2 5
4 3
5 3
4 5

Sample Output 2

0 0 0 0 0

Everyone is a friend of everyone else and has no friend candidate.

Sample Input 3

10 9 3
10 1
6 7
8 2
2 5
8 4
7 3
10 9
6 4
5 8
2 6
7 5
3 1

Sample Output 3

1 3 5 4 3 3 3 3 1 0

Solution in Rust (1.42.0) (judge verdict: Accepted)

// -*- coding:utf-8-unix -*-

#[macro_use]
extern crate lazy_static;
extern crate num_bigint; // 0.2.2
extern crate num_traits; // 0.2.8
use num_bigint::BigInt;
use num_bigint::ToBigInt;
use num_traits::{abs, pow, One, Pow, Zero};

// use proconio::derive_readable;
use proconio::fastout;
use proconio::input;
// use std::convert::TryInto;
// use ascii::Chars;
// use libm::*;
use proconio::marker::{Bytes, Chars};
use std::cmp::*;
use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque};
use std::io::*;
use std::ops::Range;
use std::str::FromStr;
use superslice::*;

use lazy_static::lazy_static;
use std::sync::Mutex;

pub fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

lazy_static! {
    // static ref PARENTS: Mutex<Vec<usize>> = Mutex::default();
    // static ref CHILDS: Mutex<Vec<Vec<usize>>> = Mutex::default();
    // static ref IS_VISITS: Mutex<Vec<bool>> = Mutex::default();
    // static ref TO_SETS: Mutex<Vec<Option<&HashSet<usize>>>> = Mutex::default();
    // static ref IS_VISITS: Mutex<Vec<bool>>> = Mutex::default();
    static ref ADJ_LIKE: Mutex<Vec<Vec<usize>>> = Mutex::default();

}

// const MOD: usize = 9997063;
// const MOD: usize = 100_000_000_ + 7;

//abc112-D
// #[fastout]
fn main() {
    input![
        n: usize,
        m: usize,
        k: usize,
        ab: [(usize, usize); m],
        cd: [(usize, usize); k]
    ];

    let mut adjs_like = ADJ_LIKE.lock().unwrap();
    *adjs_like = vec![Vec::new(); n];

    for (a, b) in ab.iter() {
        let (a, b) = (a - 1, b - 1);
        adjs_like[a].push(b);
        adjs_like[b].push(a);
    }

    let mut dislikes = vec![HashSet::new(); n];
    for (c, d) in cd.iter() {
        let (c, d) = (c - 1, d - 1);
        dislikes[c].insert(d);
        dislikes[d].insert(c);
    }

    {
        // let mut is_visits = IS_VISITS.lock().unwrap();
        // *is_visits = vec![false; n];
    }
    let mut to_sets: Vec<Option<usize>> = vec![None; n];

    // let a = Some(1);

    let mut sets = Vec::new();

    let mut set_idx = 0;
    for i in 0..n {
        if to_sets[i].is_some() {
            continue;
        }

        let new_set = HashSet::new();
        let new_set = go(i, &mut to_sets, new_set, set_idx, &adjs_like);

        sets.push(new_set);
        set_idx += 1;
    }

    // eprintln!("{:?}", sets);
    // eprintln!("{:?}", dislikes);

    for i in 0..n {
        let set_num = to_sets[i].unwrap();
        let mut ans = sets[set_num].len();

        for dislikes in dislikes[i].iter() {
            if to_sets[*dislikes].unwrap() == set_num {
                // eprintln!("{}, {}", i, dislikes);
                ans -= 1;
            }
        }

        // eprintln!(
        //     "sets: {}, direct: {}",
        //     sets[set_num].len() - 1,
        //     adjs_like[i].len()
        // );
        ans -= adjs_like[i].len();
        // eprintln!("{} ", ans - 1);
        // println!("{} ", ans - 1);
        print!("{} ", ans - 1);
    }
}

fn go(
    idx: usize,
    to_sets: &mut Vec<Option<usize>>,
    mut set: HashSet<usize>,
    set_idx: usize,
    adjs_like: &Vec<Vec<usize>>,
) -> HashSet<usize> {
    // eprintln!("{}, {:?}", idx, to_sets);
    if to_sets[idx].is_some() {
        return set;
    }

    set.insert(idx);
    // {
    to_sets[idx] = Some(set_idx);
    let adj_like = &adjs_like[idx];

    let mut current_set = set;
    for to in adj_like.iter() {
        if to_sets[*to].is_some() {
            continue;
        }
        current_set = go(*to, to_sets, current_set, set_idx, adjs_like);
    }

    // }

    return current_set;
}

// let mut values = VALUES.lock().unwrap();
// values.extend_from_slice(&[1, 2, 3, 4]);
// assert_eq!(&*values, &[1, 2, 3, 4]);

// -100000000
//  1000000000