冗余路径

题目描述：

为了从 F 个草场中的一个走到另一个，奶牛们有时不得不路过一些她们讨厌的可怕的树。

奶牛们已经厌倦了被迫走某一条路，所以她们想建一些新路，使每一对草场之间都会至少有两条相互分离的路径，这样她们就有多一些选择。

每对草场之间已经有至少一条路径。

给出所有 R 条双向路的描述，每条路连接了两个不同的草场，请计算最少的新建道路的数量，路径由若干道路首尾相连而成。

两条路径相互分离，是指两条路径没有一条重合的道路。

但是，两条分离的路径上可以有一些相同的草场。

对于同一对草场之间，可能已经有两条不同的道路，你也可以在它们之间再建一条道路，作为另一条不同的道路。

思路：

很显然，要求的是每两个点之间至少存在两条不重合的路径

这就是边双连通分量的一个性质

也就是给出一个无向图，问最少加几条边能变成一个边双连通

我们可以先进行缩点，缩完点后就变成了一棵树，树上一定会存在度数为1的叶子节点，我们只需要将起两两首尾相连就可以，如果有多余的，就任意连到一个叶子去

对无向图的边双连通分量的缩点和有向图的对强连通分量进行缩点的代码几乎一样，只需要对边进行一下判重

#include <bits/stdc++.h>
using namespace std;

#define endl '\n'
#define inf 0x3f3f3f3f
#define mod7 1000000007
#define mod9 998244353
#define m_p(a,b) make_pair(a, b)
#define mem(a,b) memset((a),(b),sizeof(a))
#define io ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define debug(a) cout << "Debuging...|" << #a << ": " << a << "\n";
typedef long long ll;
typedef pair <int,int> pii;

#define MAX 300000 + 50
int n, m, k;

int tot;
int head[MAX];
struct ran{
    int to, nex;
}tr[MAX];
inline void add(int u, int v){
    tr[++tot].to = v;
    tr[tot].nex = head[u];
    head[u] = tot;
}

int tmd;
int dfn[MAX], low[MAX];
bool vis[MAX];
stack<int>st;
int cnt;
int col[MAX];
int du[MAX];
bool g[MAX];
void tarjan(int u){
    st.push(u);vis[u] = 1;
    dfn[u] = low[u] = ++tmd;
    for(int i = head[u]; i; i = tr[i].nex){
        if(g[i])continue;//判重边
        g[i] = g[i ^ 1] = 1;
        int v = tr[i].to;
        if(!dfn[v]){
            tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else if(vis[v])low[u] = min(low[u], dfn[v]);
    }
    if(low[u] == dfn[u]){
        ++cnt;
        int now;
        do {
            now = st.top();
            st.pop();vis[now] = 0;
            col[now] = cnt;
        } while (now != u);
    }
}

void work(){
    cin >> n >> m;
    tot = 1;
    for(int i = 1, a, b; i <= m; ++i){
        cin >> a >> b;
        add(a, b);
        add(b, a);
    }
    for(int i = 1; i <= n; ++i){
        if(!dfn[i])tarjan(i);
    }
    for(int u = 1; u <= n; ++u){
        for(int i = head[u]; i; i = tr[i].nex){
            int v = tr[i].to;
            if(col[u] != col[v]){
                ++du[col[v]];
            }
        }
    }
    int ans = 0;
    for(int i = 1; i <= cnt; ++i){
        if(du[i] == 1)++ans;
    }
    cout << (ans + 1) / 2 << endl;
    
}


int main(){
    io;
    work();
    return 0;
}