<转>
[求割点与桥]
该算法是R.Tarjan发明的。对图深度优先搜索，定义DFS(u)为u在搜索树（以下简称为树）中被遍历到的次序号。定义Low(u)为u或u的子树中能通过非父子边追溯到的最早的节点，即DFS序号最小的节点。根据定义，则有：
Low(u)=Min { DFS(u) DFS(v) (u,v)为后向边(返祖边) 等价于 DFS(v)<DFS(u)且v不为u的父亲节点 Low(v) (u,v)为树枝边(父子边) }
一个顶点u是割点，当且仅当满足(1)或(2) (1) u为树根，且u有多于一个子树。 (2) u不为树根，且满足存在(u,v)为树枝边(或称父子边，即u为v在搜索树中的父亲)，使得DFS(u)<=Low(v)。
一条无向边(u,v)是桥，当且仅当(u,v)为树枝边，且满足DFS(u)<Low(v)。
[求双连通分支]
下面要分开讨论点双连通分支与边双连通分支的求法。
对于点双连通分支，实际上在求割点的过程中就能顺便把每个点双连通分支求出。建立一个栈，存储当前双连通分支，在搜索图时，每找到一条树枝边或后向边(非横叉边)，就把这条边加入栈中。如果遇到某时满足DFS(u)<=Low(v)，说明u是一个割点，同时把边从栈顶一个个取出，直到遇到了边(u,v)，取出的这些边与其关联的点，组成一个点双连通分支。割点可以属于多个点双连通分支，其余点和每条边只属于且属于一个点双连通分支。
对于边双连通分支，求法更为简单。只需在求出所有的桥以后，把桥边删除，原图变成了多个连通块，则每个连通块就是一个边双连通分支。桥不属于任何一个边双连通分支，其余的边和每个顶点都属于且只属于一个边双连通分支。
[构造双连通图]
一个有桥的连通图，如何把它通过加边变成边双连通图？方法为首先求出所有的桥，然后删除这些桥边，剩下的每个连通块都是一个双连通子图。把每个双连通子图收缩为一个顶点，再把桥边加回来，最后的这个图一定是一棵树，边连通度为1。
统计出树中度为1的节点的个数，即为叶节点的个数，记为leaf。则至少在树上添加(leaf+1)/2条边，就能使树达到边二连通，所以至少添加的边数就是(leaf+1)/2。具体方法为，首先把两个最近公共祖先最远的两个叶节点之间连接一条边，这样可以把这两个点到祖先的路径上所有点收缩到一起，因为一个形成的环一定是双连通的。然后再找两个最近公共祖先最远的两个叶节点，这样一对一对找完，恰好是(leaf+1)/2次，把所有点收缩到了一起。
<code>
http://poj.org/problem?id=2186
#include <cstdio>
#include <deque>
#include <queue>
#include <set>
#include <string>
#include <map>
#include <vector>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
typedef long long LL;
const int maxn = 10010;
template<class T>
void fout(T a){
cout << a << endl;
}
int n,m;
int pre[maxn];
int low[maxn];
int cnt;
int scnt;
//bool visited[maxn];
int id[maxn];
int out[maxn];
vector<int> e[maxn];
vector<int> scce[maxn];
int stack[maxn],top;
/*heishuzhidaoshu p377*/
void Tarjan(int u){
int w;
int imin = low[u] = pre[u] = cnt ++;
stack[++top] = u;
for(int i=0;i<e[u].size();i++){
w = e[u][i];
if(pre[w] == -1)Tarjan(w);
if(low[w] < imin)imin = low[w];
}
if(imin < low[u]){
low[u] = imin;
return ;
}
do {
w = stack[top--];
scce[scnt].push_back(w);
id[w] = scnt;
low[w] = n;
}while(w!=u);
scnt ++;
}
void solve(){
//memset(visited,false,sizeof(visited));
memset(pre,-1,sizeof(pre));
memset(low,-1,sizeof(low));
memset(out,0,sizeof(out));
cnt = 0;
top = 0;
scnt = 0;
for(int i=0;i<n;i++){
if(pre[i] == -1){
//cout << i << endl;
Tarjan(i);
}
}
for(int i=0;i<n;i++){
for(int j=0;j<e[i].size();j++){
//out[id[e[i][j]]] ++;
if(id[i] != id[e[i][j]]){
out[id[i]] ++;
}
}
}
int c = 0;
int ans;
for(int i=0;i<scnt;i++){
if(out[i] == 0){
c ++;
if(c == 1){
ans = scce[i].size();
}
}
}
if(c == 1){
printf("%d\n",ans);
}
else printf("0\n");
}
void initGraph(){
while(scanf("%d%d",&n,&m)!=-1){
for(int i=0;i<n;i++){
e[i].clear();
scce[i].clear();
}
for(int i=0;i<m;i++){
int a,b;
scanf("%d%d",&a,&b);
a --,b --;
e[a].push_back(b);
}
solve();
}
}
int main(){
initGraph();
//solve();
return 0;
}poj2553——The Bottom of a Graph
强连通分量，缩点，求出度为0的点。
#include <cstdio>
#include <deque>
#include <queue>
#include <set>
#include <string>
#include <map>
#include <vector>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
typedef long long LL;
const int maxn = 10010;
template<class T>
void fout(T a){
cout << a << endl;
}
int n,m;
int pre[maxn];
int low[maxn];
int cnt;
int scnt;
//bool visited[maxn];
int id[maxn];
int out[maxn];
vector<int> e[maxn];
vector<int> scce[maxn];
int stack[maxn],top;
/*heishuzhidaoshu p377*/
void Tarjan(int u){
int w;
int imin = low[u] = pre[u] = cnt ++;
stack[++top] = u;
for(int i=0;i<e[u].size();i++){
w = e[u][i];
if(pre[w] == -1)Tarjan(w);
if(low[w] < imin)imin = low[w];
}
if(imin < low[u]){
low[u] = imin;
return ;
}
do {
w = stack[top--];
scce[scnt].push_back(w);
id[w] = scnt;
low[w] = n;
}while(w!=u);
scnt ++;
}
void solve(){
//memset(visited,false,sizeof(visited));
memset(pre,-1,sizeof(pre));
memset(low,-1,sizeof(low));
memset(out,0,sizeof(out));
cnt = 0;
top = 0;
scnt = 0;
for(int i=0;i<n;i++){
if(pre[i] == -1){
//cout << i << endl;
Tarjan(i);
}
}
for(int i=0;i<n;i++){
for(int j=0;j<e[i].size();j++){
//out[id[e[i][j]]] ++;
if(id[i] != id[e[i][j]]){
out[id[i]] ++;
}
}
}
int c = 0;
//int ans=0;
for(int i=0;i<n;i++){
if(out[id[i]] == 0){
printf("%d ",i+1);
//ans += scce[i].size();
}
}
printf("\n");
}
void initGraph(){
while(scanf("%d",&n),n){
scanf("%d",&m);
for(int i=0;i<n;i++){
e[i].clear();
scce[i].clear();
}
for(int i=0;i<m;i++){
int a,b;
scanf("%d%d",&a,&b);
a --,b --;
e[a].push_back(b);
}
solve();
}
}
int main(){
initGraph();
//solve();
return 0;
}
http://poj.org/problem?id=1236
有向图
DAG，加边成为强连通分量
假设n为出度为0的点的个数，m为入度为0的点的个数，加的边数为max(n , m)
怎么加呢, 先假设每个连通分量都有一个入度为0的点，一个出度为0的点，那么我们就首尾将它们连起来，形成一个环，这个环就保证了是强连通分量，然后其余的点随便连到一个点就可以了
attention！ 只有1个连通分量特别考虑。
#include <cstdio>
#include <deque>
#include <queue>
#include <set>
#include <string>
#include <map>
#include <vector>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
typedef long long LL;
const int maxn = 10010;
template<class T>
void fout(T a){
cout << a << endl;
}
int n,m;
int pre[maxn];
int low[maxn];
int cnt;
int scnt;
//bool visited[maxn];
int id[maxn];
int out[maxn];
int in[maxn];
vector<int> e[maxn];
vector<int> scce[maxn];
int stack[maxn],top;
/*heishuzhidaoshu p377*/
void Tarjan(int u){
int w;
int imin = low[u] = pre[u] = cnt ++;
stack[++top] = u;
for(int i=0;i<e[u].size();i++){
w = e[u][i];
if(pre[w] == -1)Tarjan(w);
if(low[w] < imin)imin = low[w];
}
if(imin < low[u]){
low[u] = imin;
return ;
}
do {
w = stack[top--];
scce[scnt].push_back(w);
id[w] = scnt;
low[w] = n;
}while(w!=u);
scnt ++;
}
void solve(){
//memset(visited,false,sizeof(visited));
memset(pre,-1,sizeof(pre));
memset(low,-1,sizeof(low));
memset(out,0,sizeof(out));
memset(in,0,sizeof(in));
cnt = 0;
top = 0;
scnt = 0;
for(int i=0;i<n;i++){
if(pre[i] == -1){
//cout << i << endl;
Tarjan(i);
}
}
for(int i=0;i<n;i++){
for(int j=0;j<e[i].size();j++){
//out[id[e[i][j]]] ++;
if(id[i] != id[e[i][j]]){
out[id[i]] ++;
in[id[e[i][j]]] ++;
}
}
}
int outc = 0;
int inc = 0;
//int ans=0;
for(int i=0;i<scnt;i++){
if(out[i] == 0){
outc ++;
//printf("%d ",i+1);
//ans += scce[i].size();
}
if(in[i] == 0){
inc ++;
}
}
if(scnt == 1)printf("1\n0\n");
else printf("%d\n%d\n",inc,max(outc,inc));
}
void initGraph(){
while(scanf("%d",&n)!=-1){
for(int i=0;i<n;i++){
e[i].clear();
scce[i].clear();
int t;
while(scanf("%d",&t),t){
e[i].push_back(t-1);
}
}
/*
for(int i=0;i<m;i++){
int a,b;
scanf("%d%d",&a,&b);
a --,b --;
e[a].push_back(b);
}
*/
solve();
}
}
int main(){
initGraph();
//solve();
return 0;
}
poj 3352
最简单的代码
#include <iostream>
#include <cstring>
using namespace std;
int map[5001][5001], low[5001], pre[5001], state[5001], cnt = 1;
int f, r;
void dfs(int u, int v) {
pre[u] = cnt;
low[u] = cnt;
++ cnt;
for (int i = 1; i <= f; ++ i) {
if (i != v && map[u][i]) {
if (!pre[i]) {
dfs(i, u);
}
if (low[u] > low[i]) {
low[u] = low[i];
}
}
}
}
int main() {
cin >> f >> r;
for (int i = 0; i < r; ++ i) {
int a, b;
cin >> a >> b;
map[a][b] = 1;
map[b][a] = 1;
}
dfs(1, 1);
for (int i = 1; i <= f; ++ i) {
for (int j = 1; j <= f; ++ j) {
if (map[i][j] && low[i] != low[j]) {
++ state[low[i]];
}
}
}
int count = 0;
for (int i = 1; i <= f; ++ i) {
//cout << low[i] << " ";
if (state[i] == 1) {
++ count;
}
}
//cout << endl;
cout << (count + 1) / 2 << endl;
return 0;
}感觉这个比较好，先收藏起来
#include <cstdio>
#include <cstring>
#include <iostream>
#define N 5005
#define M 20005
using namespace std;
int to[M], nx[M], ghead[N];
int gcnt;
void addedge(int l, int r){
to[gcnt] = r;
nx[gcnt] = ghead[l];
ghead[l] = gcnt++;
}
int dfn[N], low[N], sta[N], Blo[N];
bool instack[N], vis[N], isBridge[M];
int bridge, block, mark, now;
void tarjan(int u, int fa){
int iter, v;
dfn[u] = low[u] = ++mark;
instack[sta[++now]=u] = vis[u] = 1;
for(iter=ghead[u];iter!=-1;iter=nx[iter]){
if((v=to[iter])==fa) continue;
if(!vis[v]){
tarjan(v,u);
low[u] = min(low[u],low[v]);
if(low[v]>low[u]) {bridge++,isBridge[iter]=true,isBridge[iter^1]=true;}
} else
if(instack[v]) low[u] = min(low[u], low[v]);
}
if(low[u]==dfn[u] && ++block)
do Blo[v=sta[now--]]=block,instack[v]=0;
while(v!=u);
}
int vol[N];
void solve(int n){
block = 0, mark = 0, bridge = 0, now = 0;
tarjan(1,0);
int tot = 0, i, iter;
for(i=1;i<=n;i++){
for(iter=ghead[i];iter!=-1;iter=nx[iter]){
if(isBridge[iter])vol[Blo[i]]++;
}
}
for(i=1;i<=block;i++)
if(vol[i]==1) tot++;
printf("%d\n",(tot+1)/2);
}
int main(){
int n, m, l, r;
gcnt = 0;
memset(ghead,-1,sizeof(ghead));
scanf("%d%d",&n,&m);
while(m--){
scanf("%d%d",&l,&r);
addedge(l,r);
addedge(r,l);
}
solve(n);
return 0;
}
模板？！
#define M 5010 //题目中可能的最大点数
int STACK[M],top=0; //Tarjan 算法中的栈
bool InStack[M]; //检查是否在栈中
int DFN[M]; //深度优先搜索访问次序
int Low[M]; //能追溯到的最早的次序
int ComponentNumber=0; //有向图强连通分量个数
int Index=0; //索引号
vector <int> Edge[M]; //邻接表表示
vector <int> Component[M]; //获得强连通分量结果
int InComponent[M]; //记录每个点在第几号强连通分量里
int ComponentDegree[M]; //记录每个强连通分量的度
void Tarjan(int i)
{
int j;
DFN[i]=Low[i]=Index++;
InStack[i]=true;
STACK[++top]=i;
for (int e=0;e<Edge[i].size();e++)
{
j=Edge[i][e];
if (DFN[j]==-1)
{
Tarjan(j);
Low[i]=min(Low[i],Low[j]);
}
else if (InStack[j])
Low[i]=min(Low[i],DFN[j]);
}
if (DFN[i]==Low[i])
{
ComponentNumber++;
do
{
j=STACK[top--];
InStack[j]=false;
Component[ComponentNumber].push_back(j);
InComponent[j]=ComponentNumber;
}
while (j!=i);
}
}
void solve(int N) //N是此图中点的个数，注意是0-indexed！
{
memset(STACK,-1,sizeof(STACK));
memset(InStack,0,sizeof(InStack));
memset(DFN,-1,sizeof(DFN));
memset(Low,-1,sizeof(Low));
for(int i=0;i<N;i++)
if(DFN[i]==-1)
Tarjan(i);
}
明天重新整理下....
1399
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
