Problem:
Score : 300 points

Problem Statement

You are given an undirected connected graph with N vertices and M edges that does not contain self-loops and double edges.

The i-th edge (1 \leq i \leq M) connects Vertex a_i and Vertex b_i.

An edge whose removal disconnects the graph is called a bridge.

Find the number of the edges that are bridges among the M edges.

Notes

A self-loop is an edge i such that a_i=b_i (1 \leq i \leq M).

Double edges are a pair of edges i,j such that a_i=a_j and b_i=b_j (1 \leq i<j \leq M).

An undirected graph is said to be connected when there exists a path between every pair of vertices.

Constraints

2 \leq N \leq 50

N-1 \leq M \leq min(N(N−1)⁄2,50)

1 \leq a_i<b_i \leq N

The given graph does not contain self-loops and double edges.

The given graph is connected.

Input

Input is given from Standard Input in the following format:

N M
a_1 b_1
a_2 b_2
:
a_M b_M

Output

Print the number of the edges that are bridges among the M edges.

Sample Input 1

7 7
1 3
2 7
3 4
4 5
4 6
5 6
6 7

Sample Output 1

4

The figure below shows the given graph:

The edges shown in red are bridges. There are four of them.

Sample Input 2

3 3
1 2
1 3
2 3

Sample Output 2

0

It is possible that there is no bridge.

Sample Input 3

6 5
1 2
2 3
3 4
4 5
5 6

Sample Output 3

5

It is possible that every edge is a bridge.

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

#[allow(unused_imports)]
use std::cmp::{max, min, Ordering};
#[allow(unused_imports)]
use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};
#[allow(unused_imports)]
use std::io::{stdin, stdout, BufWriter, Write};
#[allow(unused_imports)]
use std::iter::FromIterator;
mod util {
    use std::fmt::Debug;
    use std::io::{stdin, stdout, BufWriter, StdoutLock};
    use std::str::FromStr;
    #[allow(dead_code)]
    pub fn line() -> String {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.trim().to_string()
    }
    #[allow(dead_code)]
    pub fn chars() -> Vec<char> {
        line().chars().collect()
    }
    #[allow(dead_code)]
    pub fn gets<T: FromStr>() -> Vec<T>
    where
        <T as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.split_whitespace()
            .map(|t| t.parse().unwrap())
            .collect()
    }
    #[allow(dead_code)]
    pub fn with_bufwriter<F: FnOnce(BufWriter<StdoutLock>) -> ()>(f: F) {
        let out = stdout();
        let writer = BufWriter::new(out.lock());
        f(writer)
    }
}
#[allow(unused_macros)]
macro_rules ! get { ( [ $ t : ty ] ) => { { let mut line : String = String :: new ( ) ; stdin ( ) . read_line ( & mut line ) . unwrap ( ) ; line . split_whitespace ( ) . map ( | t | t . parse ::<$ t > ( ) . unwrap ( ) ) . collect ::< Vec < _ >> ( ) } } ; ( [ $ t : ty ] ; $ n : expr ) => { ( 0 ..$ n ) . map ( | _ | get ! ( [ $ t ] ) ) . collect ::< Vec < _ >> ( ) } ; ( $ t : ty ) => { { let mut line : String = String :: new ( ) ; stdin ( ) . read_line ( & mut line ) . unwrap ( ) ; line . trim ( ) . parse ::<$ t > ( ) . unwrap ( ) } } ; ( $ ( $ t : ty ) ,* ) => { { let mut line : String = String :: new ( ) ; stdin ( ) . read_line ( & mut line ) . unwrap ( ) ; let mut iter = line . split_whitespace ( ) ; ( $ ( iter . next ( ) . unwrap ( ) . parse ::<$ t > ( ) . unwrap ( ) , ) * ) } } ; ( $ t : ty ; $ n : expr ) => { ( 0 ..$ n ) . map ( | _ | get ! ( $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ ( $ t : ty ) ,*; $ n : expr ) => { ( 0 ..$ n ) . map ( | _ | get ! ( $ ( $ t ) ,* ) ) . collect ::< Vec < _ >> ( ) } ; }
#[allow(unused_macros)]
macro_rules ! debug { ( $ ( $ a : expr ) ,* ) => { eprintln ! ( concat ! ( $ ( stringify ! ( $ a ) , " = {:?}, " ) ,* ) , $ ( $ a ) ,* ) ; } }
const BIG_STACK_SIZE: bool = true;
#[allow(dead_code)]
fn main() {
    use std::thread;
    if BIG_STACK_SIZE {
        thread::Builder::new()
            .stack_size(32 * 1024 * 1024)
            .name("solve".into())
            .spawn(solve)
            .unwrap()
            .join()
            .unwrap();
    } else {
        solve();
    }
}
#[allow(dead_code)]
fn read<T>() -> Vec<T>
where T:
    std::str::FromStr,
    T::Err: std::fmt::Debug {

    let mut buf = String::new();
    stdin().read_line(&mut buf).unwrap();
    buf.split_whitespace()
        .map(|s| s.trim().parse().unwrap())
        .collect()
}

#[derive(Clone)]
struct Node {
    id: usize,
    nodes: Vec<usize>,
}

#[derive(Clone)]
struct Graph {
    nodes: Vec<Node>
}

impl Graph {
    fn new(ab: Vec<(usize, usize)>) -> Self {
        let mut new = Graph{ nodes: Vec::new() };
        for (a, b) in ab {
            if let Some(index) = new.nodes.iter().position(|t| t.id == a) {
                new.nodes[index].nodes.push(b);
            } else {
                new.nodes.push(Node{ id: a, nodes: vec![b] });
            }

            if let Some(index) = new.nodes.iter().position(|t| t.id == b) {
                new.nodes[index].nodes.push(a);
            } else {
                new.nodes.push(Node{ id: b, nodes: vec![a] });
            }
        }
        new
    }


    fn get(&self, id: usize) -> Option<&Node> {
        self.nodes.iter().find(|a| a.id == id)
    }


    fn get_mut<'a>(&'a mut self, id: usize) -> Option<&'a mut Node> {
        for i in 0..self.nodes.len() {
            if self.nodes[i].id == id {
                return Some(&mut self.nodes[i]);
            }
        }
        None
    }

    fn cut(&mut self, lid: usize, rid: usize) {
        {
            let lnode = self.get_mut(lid).unwrap();
            let li = lnode.nodes.iter().position(|a| *a == rid).unwrap();
            lnode.nodes.remove(li);
        }
        {
            let rnode = self.get_mut(rid).unwrap();
            let ri = rnode.nodes.iter().position(|a| *a == lid).unwrap();
            rnode.nodes.remove(ri);
        }
    }


    fn is_connected(&self) -> bool {
        let first = &self.nodes[0];
        let mut queue = VecDeque::new();
        let mut exist = BTreeSet::new();

        queue.push_back(first.id);
        exist.insert(first.id);

        while !queue.is_empty() {
            let node = self.get(queue.pop_front().unwrap()).unwrap();
            for new in &node.nodes {
                if !exist.contains(&new) {
                    exist.insert(*new);
                    queue.push_back(*new);
                }
            }
        }
        exist.len() == self.nodes.len()
    }
}

fn solve() {
    let (_n, m) = get!(usize, usize);
    let ab = get!(usize, usize; m);

    let graph = Graph::new(ab.clone());
    let mut count = 0;
    for (a, b) in ab {
        let mut tmp = graph.clone();
        tmp.cut(a, b);
        if !tmp.is_connected() {
            count +=  1;
        }
    }
    println!("{}", count);
}