大致题意:
为了保护放牧环境,避免牲畜过度啃咬同一个地方的草皮,牧场主决定利用不断迁移牲畜进行喂养的方法去保护牧草。然而牲畜在迁移过程中也会啃食路上的牧草,所以如果每次迁移都用同一条道路,那么该条道路同样会被啃咬过度而遭受破坏。
现在牧场主拥有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;
}