CONSTRUCT (CSPTST 2017-2018)

#include <bits/stdc++.h>
#define task ""
using namespace std;
using ll = long long;
using ld = long double;

const int N = 1e5 + 5;
struct dsu{
    int par[N];
    dsu() {
        memset(par, -1 , sizeof par);
    }
    int findpar(int v) {
        return par[v] < 0 ? v : par[v] = findpar(par[v]);
    }
    void Merge(int v, int u) {
        u = findpar(u);
        v = findpar(v);
        if(u == v) return;
        if(par[u] < par[v]) swap(u, v);
        par[v] += par[u];
        par[u] = v;
    }
} f;

int m, n, low[N], num[N], l(0), dp[N];
int id[N * 2], x[N * 2], y[N * 2];
int max1[N], max2[N], dep[N];
vector<pair<int, int>> adj[N];
vector<int> nadj[N];
bool critical[N * 2], ck[N];

void Read() {
    cin >> n >> m;
    for(int i = 1; i <= m; ++i) {
        int u, v;
        cin >> u >> v;
        id[i] = i;
        if(u != v) {
            x[i] = u;
            y[i] = v;
            adj[u].emplace_back(v, i);
            adj[v].emplace_back(u, i);
        }
    }
}

void dfs(int v, int p) {
    low[v] = num[v] = ++l;
    for(auto i : adj[v])
        if(i.first != p) {
            if(num[i.first]) low[v] = min(low[v], num[i.first]);
            else {
                dfs(i.first, v);
                low[v] = min(low[v], low[i.first]);
                critical[i.second] = low[i.first] > low[v];
            }
        }
}

void dfs2(int v) {
    ck[v] = 1;
    max1[v] = max2[v] = dep[v];
    dp[v] = 0;

    for(auto i : nadj[v])
        if(!ck[i]) {
            dep[i] = dep[v] + 1;
            dfs2(i);
            dp[v] = max(dp[v], dp[i]);
            if(max1[v] < max1[i]) {
                max2[v] = max1[v];
                max1[v] = max1[i];
            }
            else if(max2[v] < max1[i]) max2[v] = max1[i];
        }
    dp[v] = max(dp[v], max1[v] + max2[v] - 2 * dep[v]);
}

void Solve() {
    for(int i = 1; i <= n; ++i)
        if(!num[i])
            dfs(i, 0);
    sort(id + 1, id + m + 1, [&](const int &u, const int &v) {
         return x[u] < x[v] || (x[u] == x[v] && y[u] < y[v]);
    });
    //cerr << "ok\n";

    for(int i = 1, j = 1; i <= m; ++i) {
        while(j <= m && x[id[i]] == x[id[j]] && y[id[i]] == y[id[j]]) ++j;
        if(j - i > 1)
            while(i < j) critical[id[i++]] = 0;
        i = j - 1;
    }

    for(int i = 1; i <= m; ++i)
        if(!critical[i] && x[i] && y[i])
            f.Merge(x[i], y[i]);

    for(int i = 1; i <= m; ++i)
        if(critical[i] && x[i] && y[i]) {
            nadj[f.findpar(x[i])].emplace_back(f.findpar(y[i]));
            nadj[f.findpar(y[i])].emplace_back(f.findpar(x[i]));
        }

    int ans(0);

    for(int i = 1; i <= n; ++i)
        if(!ck[f.findpar(i)]) {
            dfs2(f.findpar(i));
            ans = max(ans, dp[f.findpar(i)]);
        }

    cout << ans;
}

int32_t main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    Read();
    Solve();
}