poj 3177 Redundant Paths

双连通分量

题意：给一个无向图，问要添加多少条边形成边双连通分量。注意图一开始是连通的，所以只要从一个点开始dfs一次就行了，另外这图有重边，（1,2）（2,1）这样，则1,2就形成了一个边双连通分量。

之前写的求边双连通分量的代码不能处理重边，但是要修改过来其实挺简单的。重边无非是遇到一个问题，从u走到v，按一般的做法，是不能从v回到u的，即不能马上就回到它父亲节点去（其实指的是不能重复走这条边，这条边虽然是无向边但是只能走一次），但是有了重边后，是可以马上回到它父亲处的，只不过走的是另一条边。所以我们可以标记哪些边用过了，每条边只能用一次，用过一次后不能再用。而且别忘了，建图的时候，无向边是分成两条有向边来保存的，所以当一条有向边被使用后，它对应的另一条反边也不能使用了，要一同标记（这样才起到了每条无向边只能走一次的效果），标记的方法很常用，e[k].used = e[k^1].used = 1;  神奇的位运算

然后这个方格其实是个更好的方法，另外这样的代码，是能够同时处理有重边和无重边的情况的，所以就这样运行一下tarjan就能出结果

#include <iostream>
#include <vector>
#include <utility>
#include <stack>
#include <cstdio>
#include <cstring>
using namespace std;
#define N 5010
#define M 10010

int n,tot;
int head[N],dfn[N],low[N],belong[N],ins[N],de[N],dcnt,bcnt;
typedef pair<int,int>pii;
struct edge
{
    int u,v,used,next;
}e[2*M];
vector<pii>bridge;
stack<int>sta;

void add(int u , int v , int k)
{
    e[k].u = u; e[k].v = v; e[k].used = 0;
    e[k].next = head[u]; head[u] = k++;
    u = u^v; v = u^v; u = u^v;
    e[k].u = u; e[k].v = v; e[k].used = 0;
    e[k].next = head[u]; head[u] = k++;
}

void dfs(int u ,int fa)
{
    dfn[u] = low[u] = ++dcnt;
    sta.push(u); ins[u] = 1;
    for(int k=head[u]; k!=-1; k=e[k].next)
        if(!e[k].used)
        {
            e[k].used = e[k^1].used = 1;
            int v = e[k].v;
            if(!dfn[v]) //树边
            {
                dfs(v , u);
                low[u] = min(low[u] , low[v]);
                if(low[v] > dfn[u]) //桥
                {
                    bridge.push_back(make_pair(u,v));
                    ++bcnt;
                    while(true)
                    {
                        int x = sta.top();
                        sta.pop(); ins[x] = false;
                        belong[x] = bcnt;
                        if(x == v) break;
                    }
                }
            }
            else if(ins[v]) //后向边
                low[u] = min(low[u] , dfn[v]);
        }
}

void solve()
{
    bridge.clear();
    while(!sta.empty()) sta.pop();
    memset(ins,0,sizeof(ins));
    memset(dfn,0,sizeof(dfn));
    memset(de,0,sizeof(de));
    dcnt = bcnt = 0;
    dfs(1,-1);
    ++bcnt;
    while(!sta.empty())
    {
        int x = sta.top();
        sta.pop(); ins[x] = 0;
        belong[x] = bcnt;
    }

//    for(int i=1; i<=n; i++)
//        cout << i << "[" << low[i] << "]" << endl;

    for(int i=0; i<bridge.size(); i++)
    {
        int u = bridge[i].first;
        int v = bridge[i].second;
        de[belong[u]]++;
        de[belong[v]]++;
    }
    int leaf = 0;
    for(int i=1; i<=bcnt; i++)
        if(de[i] == 1)
            leaf++;
    cout << (leaf+1)/2 << endl;
}

int main()
{
    while(cin >> n >> tot)
    {
        tot *= 2;
        memset(head,-1,sizeof(head));
        for(int i=0; i<tot; i+=2)
        {
            int u,v;
            cin >> u >> v;
            add(u,v,i);
        }
        solve();
    }
    return 0;
}