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 Scala (2.11.7) (judge verdict: Accepted)

object Main {

  class UnionFind(par: Array[Int]) {

    def root(x: Int): Int =
      if (par(x) == x) x
      else {
        par(x) = root(par(x))
        par(x)
      }

    def unite(x: Int, y: Int): Unit = {
      val rx = root(par(x))
      val ry = root(par(y))
      if (rx != ry)
        par(rx) = ry
    }

    def same(x: Int, y: Int): Boolean =
      root(par(x)) == root(par(y))

  }

  object UnionFind {
    def apply(N: Int): UnionFind =
      new UnionFind(Array.range(0, N))
  }

  def main(args: Array[String]): Unit = {
    // 頂点数が最大50頂点, 辺の数は最大50本.
    // 50本の辺について全て以下を試す
    // 対象の辺以外の全ての辺を繋いだDisjointSetを作り,
    // 対象の辺を繋ぐ前にすでに連結しているかを確認する.
    val sc = new java.util.Scanner(System.in)

    val N, M = sc.nextInt()

    case class Bridge(a: Int, b: Int)

    val bridges = new Array[Bridge](M)
    (0 until M) foreach { i =>
      val a, b = sc.nextInt()
      bridges(i) = Bridge(a-1,b-1)
    }

    var i = 0
    var count = 0
    while (i < M) {
      val set = UnionFind(N)
      var j = 0
      while (j < M) {
        if (i != j) {
          val bridge = bridges(j)
          set.unite(bridge.a, bridge.b)
        }
        j += 1
      }
      val bridge = bridges(i)
      if (!set.same(bridge.a, bridge.b))
        count += 1
      i += 1
    }

    println(count)
  }

}