求有重边的无向图的割边算法

如果图没有重边，那么一般的求割边tarjan算法是这么操作的。

dfs访问每一个点时，为这个点分配一个时间戳dfn[]，根据访问次序的先后，时间戳从小到大

对于边(u,v)是不是割边，如果lowv > dfn[u],那么边(u,v)是割边，反之不是。 lowv表示的是从点v开始dfs，所能访问到的最小时间戳。

如果从点v开始dfs，访问到的时间戳<=dfn[u]那么说明v或者v的子树有一条连向u或者u祖先的边。

从点1开始dfs，dfn[1] = 1, 沿边访问到点2，然后从点2开始dfs，但是点2没有连回1的边，所以边(1,2)是割边

 1 #include <stdio.h>
 2 #include <string.h>
 3 #include <vector>
 4 using namespace std;
 5 const int N = 1000 + 10;
 6 vector<int> g[N];
 7 int dfs_clock,pre[N];
 8 int cnt;
 9 int dfs(int u, int fa)
10 {
11     int lowu = pre[u] = ++dfs_clock;
12     int i,v,lowv;
13     for(i=0; i<g[u].size(); ++i)
14     {
15         v = g[u][i];
16         if(!pre[v])
17         {
18             lowv = dfs(v,u);
19             lowu = min(lowu,lowv);
20             if(lowv > pre[u])//相对于割点，只把等号给去掉了
21                 cnt++;
22         }
23         else if(v!=fa && pre[v]<lowu)//v!=fa，说明不能用反向边来更新
24             lowu = pre[v];
25     }
26     return lowu;
27 }
28 int main()
29 {
30     int i,x,y;
31     int n,m;
32     scanf("%d%d",&n,&m);
33     for(i=0; i<m; ++i)
34     {
35         scanf("%d%d",&x,&y);
36         g[x].push_back(y);
37         g[y].push_back(x);
38     }
39     dfs(1,-1);
40 
41     printf("%d\n",cnt);
42 }

View Code

 

但是事实上，图经常有重边，而且题目经常喜欢重边，但是又不会给出说明，所以为了安全起见，要学会怎么处理有重边的无向图的割桥。

上面的tarjan算法有两个参数(u,fa),其中参数fa用来判断(x,t)是不是刚刚走过来的那条边，即如果fa==t，说明是刚刚走过来的那条边

在有重边的情况下， 这样就不太好判断了

如图

因为是重边，所以边(1,2)不是割桥。，1走到2，我们可以从2走到1，但是如果按照上面的tarjan算法，由于是用点来判断某条边是不是走过

那么重边的情况下，就会误判。

为了防止误判，我们要用边来判断。

具体实现是我们给边编号，因为存边的时候，是分为两条有向边存储的，我们让编号从0开始，那么如果两条有向边的编号/2是相等的，那么就说明这两条边是一条边

而参数fa改成刚刚走过的边的编号

1从id为0的边走到2，不能从id为1的边走到1，但是可以从id为3的边走到1.

 1 #include <stdio.h>
 2 #include <string.h>
 3 #include <vector>
 4 using namespace std;
 5 const int N = 5000;
 6 struct node
 7 {
 8     int v,id;
 9 };
10 vector<node> g[N];
11 int dfn[N],dfs_clock,cntCut;
12 int dfs(int u, int id)
13 {
14     int lowu = dfn[u] = ++dfs_clock;
15     int lowv,i,v;
16     for(i=0; i<g[u].size();++i)
17     {
18         v = g[u][i].v;
19         if(!dfn[v])
20         {
21             lowv = dfs(v,g[u][i].id);
22             lowu = min(lowu,lowv);
23             if(lowv > dfn[u])
24                 cntCut++;
25         }
26         else if(id/2 != g[u][i].id/2 &&dfn[v]<lowu)//如果刚才走过来的边的id/2和这个边的id/2不相等，那么说明这两条有向边不是从一条边分离出来的
27             lowu = dfn[v];
28     }
29     return lowu;
30 }
31 int main()
32 {
33     int n,m,i,a,b;
34     scanf("%d%d",&n,&m);
35     for(i=0; i<m; ++i)
36     {
37         scanf("%d%d",&a,&b);
38         node t;
39         t.v = a;
40         t.id = i * 2;//给边编号
41         g[b].push_back(t);
42         t.v = b;
43         t.id = i * 2 + 1;
44         g[a].push_back(t);
45     }
46     dfs(1,-2);
47     printf("%d\n",cntCut);
48     return 0;
49 }

View Code

 

其实还有更简单的办法，因为如果有重边(u,v), 那么边(u,v)肯定被存了两次，所以我们只要让它第二次访问时通过就可以了

 1 #include <stdio.h>
 2 #include <string.h>
 3 #include <stdlib.h>
 4 #include <algorithm>
 5 #include <iostream>
 6 #include <queue>
 7 #include <stack>
 8 #include <vector>
 9 #include <map>
10 #include <set>
11 #include <string>
12 #include <math.h>
13 using namespace std;
14 typedef long long LL;                   
15 const int INF = 1<<30;
16 const int N  = 1000 + 10;
17 int dfn[N],low[N],dfs_clock;
18 vector<int> g[N];
19 int cntCut;
20 void tarjan(int u, int fa)
21 {
22     dfn[u] = low[u] = ++dfs_clock;
23     bool flag = false;
24     for(int i=0; i<g[u].size(); ++i)
25     {
26         int v = g[u][i];
27         if(v==fa && !flag)//如果有重边，那么边(u,v)被存了两次，所以，如果第二次访问，就让他通过
28         {
29             flag = true;
30             continue;
31         }
32         if(dfn[v]==0) 
33             tarjan(v,u);
34         low[u] = min(low[u],low[v]);
35         if(low[v] > dfn[u])
36             cntCut++;
37     }
38 }
39 int main()
40 {
41     int n,m,i,a,b;
42     scanf("%d%d",&n,&m);
43     for(i=0; i<m; ++i)
44     {
45         scanf("%d%d",&a,&b);
46         g[a].push_back(b);
47         g[b].push_back(a);
48     }
49     tarjan(1,-1);
50     printf("%d\n",cntCut);
51     return 0;
52 }

View Code

 

转载于:https://www.cnblogs.com/justPassBy/p/4387053.html