hoj2360Redundant Paths双连通

大致题意：

       为了保护放牧环境，避免牲畜过度啃咬同一个地方的草皮，牧场主决定利用不断迁移牲畜进行喂养的方法去保护牧草。然而牲畜在迁移过程中也会啃食路上的牧草，所以如果每次迁移都用同一条道路，那么该条道路同样会被啃咬过度而遭受破坏。

       现在牧场主拥有F个农场，已知这些农场至少有一条路径连接起来（不一定是直接相连），但从某些农场去另外一些农场，至少有一条路可通行。为了保护道路上的牧草，农场主希望再建造若干条道路，使得每次迁移牲畜时，至少有2种迁移途径，避免重复走上次迁移的道路。已知当前有的R条道路，问农场主至少要新建造几条道路，才能满足要求？

解题思路：

“使得每次迁移牲畜时，至少有2种迁移途径，避免重复走上次迁移的道路。”就是说当吧F个农场看作点、路看作边构造一个无向图G时，图G不存在桥。

那么可以建立模型：

       给定一个连通的无向图G，至少要添加几条边，才能使其变为双连通图。

这题是和POJ3352一模一样的题，只不过表述方式不同而已。

本题和3353最大的区别就是，3353保证了没有重边，而本题有重边。

而3353的解题报告已经说过，当两点之间出现重边时，就不可以利用Low值去划分【边双连通分量】了，因为此时不同Low值的两点可能属于同一个【边双连通分量】！

那么如何解决重边的问题？

1、  构造图G时把重边也考虑进来，然后在划分边双连通分量时先把桥删去，再划分，其中桥的一端的割点归入当前正在划分的边双连通分量。这个处理比较麻烦；

2、  在输入图G的边时，若出现重边，则不把重边放入图G，然后在划分边双连通分量时依然用Low划分。

两者相权，当然是第2种方法更好处理了。

其实用邻接矩阵去存储图G的同学，是无需考虑重边的问题的。

但是用邻接链表去存储图G的同学就不得不考虑了，因为基本上都是用头插入法在链表中插入边的，所以无法检测重边。而改用尾插入法，则可以在指针从链头移到链尾的同时，顺便加一个判断，出现重边则不再插入，否则插入到尾部。

#include <cstdio>
#include <string.h>
const int maxn = 10001;
struct node
{
    int to;
    int next;
} e[maxn];
int head[maxn];
int ansi;
int top;//栈中的元素个数
int cnt;//记录边连通分量编号
int Index;//记录遍历的步数
int dfn[maxn];//记录节点u第一次被访问时的步数
int low[maxn];//记录与节点u和u的子树节点中最早的步数
bool instack[maxn];//记录节点u是否在栈中
int stack[maxn];//栈
int Belong[maxn];//记录每个节点属于的强连通分量编号
int N;//节点个数
int ans[maxn];//顶点出度记录
//bool Flag[5002][5002];
int min(int a, int b){ return a < b ? a : b;}
void add(int a, int b)
{
    e[ansi].to = b;
    e[ansi].next = head[a];
    head[a] = ansi++;
}
void tarjan(int i, int from)
{
    int j;
    dfn[i] = low[i] = ++Index;
    instack[i] = true;
    stack[++top] = i;
    bool flag = false;
    for (int k = head[i]; k != -1; k = e[k].next)
    {
        j = e[k].to;
        if (j == from && !flag) //这个flag是为了处理重边，正常情况下只要判断j==from就行了
            flag = true;
        else
        {
            if (!dfn[j])
            {
                tarjan(j, i);
                low[i] = min(low[i], low[j]);
            }
            else if (instack[j] && low[j] < low[i])
                low[i] = low[j];
        }
    }
    //节点i是强连通分量的根
    if (dfn[i] == low[i])
    {
        //退栈，直至找到根为止
        do
        {
            j = stack[top--];
            instack[j] = false;
            Belong[j] = cnt;
        }
        while (j != i);
        cnt++;
    }
}
void solve()
{
    top = cnt = Index = 0;
    memset(dfn, 0, sizeof(dfn));
    memset(ans, 0, sizeof(ans));
    memset(instack, 0, sizeof(instack));
    int re = 0;
    int i, j;
    for (i = 1; i <= N; i++)
        if (!dfn[i]) //有可能不是连通图
            tarjan(i, -1);

    for (i = 1; i <= N; i++)
        for (j = head[i]; j != -1; j = e[j].next)
            if (Belong[i] != Belong[e[j].to])
                ans[Belong[i]]++;//出度加1
    for (i = 0; i < cnt; i++)
        if (ans[i] == 1)
            re++;
    printf("%d\n", (re + 1) / 2);
}
int main()
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif
    int M,a,b;
    while (scanf("%d %d", &N, &M) != EOF)
    {
        ansi = 0;
        memset(head, -1, sizeof(head));
 //     memset(Flag, 0, sizeof(Flag));
        for (int i = 0; i < M; i++)
        {
            scanf("%d%d", &a, &b);
//            if(Flag[a][b]||Flag[b][a])continue;//在输入的时候处理重边
//            Flag[a][b]=Flag[b][a]=1;
            add(a, b);
            add(b, a);
        }
        solve();
    }
    return 0;
}


//附一神代码,写的太简洁了！
#include <stdio.h>
#include <vector>
using namespace std;
int f,r,low[5005],visit[5005],degree[5005],count;
bool connect[5005][5005];
vector< vector<int> >adj;
int min(int x, int y)
{
    return x<y?x:y;
}
void dfs(int x, int p)
{
    visit[x]=true;
    low[x]=count++;
    int len=adj[x].size();
    for(int i=0;i<len;i++)
    {
        if(adj[x][i]==p) continue;
        if(!visit[adj[x][i]]) 
          dfs(adj[x][i],x);
        low[x]=min(low[x],low[adj[x][i]]);
    }
}
int main()
{
    int a,b;
    scanf("%d%d",&f,&r);
    adj.assign(f+1,vector<int>());
    while(r--)
    {
        scanf("%d%d",&a,&b);
        if(!connect[a][b])
        {
            connect[a][b]=true;
            adj[a].push_back(b);
            adj[b].push_back(a);
        }
    }
    count=0;
    dfs(1,1);
    for(int i=1;i<=f;i++)
    {
        int len=adj[i].size();
        for(int j=0;j<len;j++)
        {
            if(low[i]!=low[adj[i][j]])
            {
                degree[low[i]]++;
            }
        }
    }
    int ans=0;
    for(int i=0;i<=f;i++)
    {
        if(degree[i]==1)
        {
            ans++;
        }
    }
    printf("%d/n",(ans+1)>>1);
    return 0;
}