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 C++14 (GCC 5.4.1) (judge verdict: Runtime Error)

#include<bits/stdc++.h>
using namespace std;
using ll=long long;
#define rep(i,n) for(int i=0;i<n;i++)

class union_find{
private:
    vector<int>parent;
    vector<int>rank;
    int cnt;
public:
    union_find(int vertex_num){
        parent.resize(vertex_num);
        rank.resize(vertex_num);
        cnt=vertex_num;
        rep(i,vertex_num){
            parent[i]=i;
            rank[i]=0;
        }   
    }
    int get_root(int n /*知りたい根の頂点の番号*/){
        if(parent[n]==n){
            return n;
        }else{
            return get_root(parent[n]);
        }
    }
    bool is_same(int a,int b /*連結を判定したい2頂点*/){
        return get_root(a) == get_root(b);
    }

    void unite(int a,int b){
        int root_a=get_root(a);
        int root_b=get_root(b);
        if(root_a==root_b)return;

        if(rank[root_a]<rank[root_b]){
            parent[root_a]=root_b;
            cnt--;
        }else if(rank[root_a]>rank[root_b]){
            parent[root_b]=root_a;
            cnt--;
        }else{
            parent[root_a]=root_b;
            ++rank[root_b];
            cnt--;
        }
    }
    int ans(){
        return cnt;
    }

};

int main(){
    int n,m,ans=0;
    cin>>n>>m;
    int a[n],b[n];
    rep(i,m){
        cin>>a[i]>>b[i];
        a[i]--;b[i]--;
    }
    rep(i,m){
        union_find uf(n);
        rep(j,m){
            if(i==j)continue;
            uf.unite(a[j],b[j]);
        }
        if(uf.ans()!=1)ans++;   
    }
    cout<<ans<<endl;

       
}