HDU 3849 By Recognizing These Guys, We Find Social Networks Useful

大意：给定一张无向图，图可能不连通，让你求图中的桥，以及该桥两端连接的端点的全称，输出按输入顺序从小到大输出。

思路：求出桥边，当前边的序号为奇数时，存储正向边，因为可能存在v->u的情况，于是把边反向u->v，然后排一次序输出即可。

 

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <string>
#include <cstring>
#include <cmath>
#include <vector>
#include <queue>
#include <algorithm>
#include <map>
using namespace std;

const int maxn = 10010;
const int maxm = 200010*2;
const int INF = 0x3f3f3f3f;

struct Edge
{
    int u, v, w;
    int next;
    int id;
}edge[maxm], edge2[maxm];

int first[maxn], stack[maxn], ins[maxn], dfn[maxn], low[maxn];
int first2[maxn];
int belong[maxn];
int ind[maxn], outd[maxn];

int cost[maxn];
int w[maxn];

int n, m;
int cnt, cnt2;
int scnt, top, tot;

map<string, int> Map;
map<int, string> city;

void init()
{
    cnt = cnt2 = 0;
    scnt = top = tot = 0;
    memset(first, -1, sizeof(first));
    memset(dfn, 0, sizeof(dfn));
    memset(ins, 0, sizeof(ins));
    Map.clear();
    city.clear();
}

void read_graph(int u, int v, int id)
{  
    edge[cnt].u = u, edge[cnt].v = v, edge[cnt].id = id;
    edge[cnt].next = first[u], first[u] = cnt++;  
}

vector<Edge> bridge;

void dfs(int u, int fa)
{
    int v;
    low[u] = dfn[u] = ++tot;
    stack[top++] = u;
    ins[u] = 1;
    bool repeat = 0;
    for(int e = first[u]; e != -1; e = edge[e].next)
    {
        v = edge[e].v;
        if(v == fa && !repeat) { repeat = 1; continue; }
        if(!dfn[v])
        {
            dfs(v, u);
            low[u] = min(low[u], low[v]);
            if(dfn[u] < low[v])
            {
                if(e & 1) bridge.push_back(edge[e-1]); //反向边，把它变为正向边
                else bridge.push_back(edge[e]);
            }
        }
        else if(ins[v]) { low[u] = min(low[u], dfn[v]); }
    }
    if(low[u] == dfn[u])
    {
        scnt++;
        do { v = stack[--top]; belong[v] = scnt; ins[v] = 0; cost[scnt] += w[v]; } while(u != v);
    }
}

void Tarjan()
{
    dfs(1, -1);
}

void read_case()
{
    init();
    scanf("%d%d", &n, &m);
    int index = 0;
    for(int i = 1; i <= m; i++)
    {
        string s1, s2;
        cin>>s1>>s2;
        if(!Map[s1]) Map[s1] = ++index, city[index] = s1;
        if(!Map[s2]) Map[s2] = ++index, city[index] = s2;
        int u = Map[s1], v = Map[s2];
        read_graph(u, v, i), read_graph(v, u, i);
    }
}

int cmp(const Edge a, const Edge b)
{
    return a.id < b.id;
}

void solve()
{
    read_case();
    bridge.clear();
    Tarjan();
    for(int i = 1; i <= n; i++) if(!dfn[i]) { printf("0\n"); return ; } //不连通 
    int size = bridge.size();
    sort(bridge.begin(), bridge.end(), cmp); //排序 
    printf("%d\n", size);
    for(int i = 0; i < size; i++)
    {
        int u = bridge[i].u, v = bridge[i].v;
        cout<<city[u]<<" "<<city[v]<<endl;
    }
}

int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        solve();
    }
    return 0;
}