题意

给你N个点，M条边，问最少增加多少条边可以使得整个图变为边双连通的？

思路

边-双连通求法
①先做一次dfs标记出所有的桥
②在做一次dfs找出边-双连通分量。
因为边-双连通分量是没有公共结点的，所以只要在第二次dfs的时候保证不经过桥即可。
求得边-双连通分量以后，把每个连通分量看作点，然后会形成一棵树。
若要使得任意一棵树，在增加若干条边后，变成一个双连通图，那么
至少增加的边数 =（ 这棵树总度数为1的结点数 + 1 ）/ 2
证明，自己画一画就能感性认知到吧

数据链接：数据

//#include <bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <stack>
using namespace std;
const int MAXN = 1e5 + 5;
const int MAXM = 1e5 + 5;
struct Edge
{
    int from, to;
    Edge (int from, int to): from(from), to(to) {}
};
struct EdgeBCC//边双联通分量
{
    int n, m;
    int LOW[MAXN], DFN[MAXN], bccno[MAXN], dfs_clock, bcc_cnt;
    bool isbridge[MAXM];
    vector<Edge> edges, bridge;
    vector<int> G[MAXN];
    void init(int n)
    {
        this->n = n;
        edges.clear();
        for (int i = 0; i <= n; i++) G[i].clear();
    }
    void AddEdge (int from, int to) 
    { 
        edges.push_back(Edge(from, to));
        edges.push_back(Edge(to, from));
        m = edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }
    int dfs(int u, int fa)
    {
        int lowu = DFN[u] = ++dfs_clock;
        int child = 0;
        bool flag = false;
        for (int i = 0; i < G[u].size(); i++)
        {
            Edge& e = edges[G[u][i]];
            int v = e.to;
            if (v == fa && !flag) { flag = true; continue; }
            if (!DFN[v]) //没有访问过v
            {
                child++;
                int lowv = dfs(v, u);
                lowu = min(lowu, lowv); //用后代的low函数更新自己
                if (lowv > DFN[u])//桥
                {
                    bridge.push_back(Edge(min(u, v), max(u, v)));
                    isbridge[G[u][i]] = isbridge[G[u][i]^1] = true;
                }   
            }
            else if (DFN[v] < DFN[u])
                lowu = min(lowu, DFN[v]); //用反向边更新自己
        }
        LOW[u] = lowu;
        return lowu;
    }
    void dfs2(int u)
    {
        bccno[u] = bcc_cnt;
        for(int i = 0; i < G[u].size(); i++)
        {
            Edge e = edges[G[u][i]];
            if(!isbridge[G[u][i]] && !bccno[e.to])
                dfs2(e.to);
        }
    }
    void find_bcc()
    {
        memset(DFN, 0, sizeof(DFN)), memset(LOW, 0, sizeof(LOW));
        bridge.clear(), memset(bccno, 0, sizeof(bccno));
        dfs_clock = bcc_cnt = 0;
        for (int i = 0; i < n; i++)
            if (!DFN[i]) dfs(i, -1);
        for(int i = 0; i < n; i++)
            if(!bccno[i]) bcc_cnt++, dfs2(i);
    }

}gao;

int n, m, deg[MAXN];
int main()
{
    scanf("%d%d", &n, &m);
    gao.init(n);
    while (m--)
    {
        int u, v; scanf("%d%d", &u, &v);
        u--, v--;
        gao.AddEdge(u, v);
    }
    gao.find_bcc();
    for (int i = 0; i < gao.bridge.size(); i++)//遍历所有桥边
    {
        int u = gao.bridge[i].from, v = gao.bridge[i].to;
        deg[gao.bccno[u]]++, deg[gao.bccno[v]]++;
    }
    int ans = 0;
    for (int i = 1; i <= gao.bcc_cnt; i++)
        if (deg[i] == 1) ans++;
    ans = (ans+1)/2;
    printf("%d\n", ans);
    return 0;
}
/*
7 7
1 2
2 3
3 4
2 5
4 5
5 6
5 7
*/