Tarjan的基本概率可以通过下面来了解
Tarjan讲解参考1
Tarjan讲解参考2
Tarjan讲解参考3
Tarjan模版:
定义变量解释:
tot用来保存当前遍历到的次序
DFN[i]表示i被遍历的次序(1,2,3,4…) 每个点的DFN都是独一无二的
LOW[i]表示i所在的强连通图中的点中最小的遍历次序,同一个强连通图中的点的LOW是相同的
cntp记录强连通图数量
pa[i]用来记录i点所在连通图(图按1,2,3,…标记)
stack[i]模拟栈的操作,用来保存同一连通图中的点
#include<cstdio>
#include<algorithm>
#include<string.h>
using namespace std;
#define maxn 1001
struct node {
int v,next;
}edge[maxn];
int DFN[maxn],LOW[maxn];
int pa[maxn],cntp; //记录各点所在的连通图
int stack[maxn],heads[maxn],visit[maxn],cnt,tot,index;
void add(int x,int y)
{
edge[++cnt].next=heads[x];
edge[cnt].v = y;
heads[x]=cnt;
return ;
}
void tarjan(int x)//代表第几个点在处理。递归的是点。
{
DFN[x]=LOW[x]=++tot;// 新进点的初始化。
stack[++index]=x;//进站
visit[x]=1;//表示在栈里
for(int i=heads[x];i!=-1;i=edge[i].next)
{
if(!DFN[edge[i].v]) {//如果没访问过
tarjan(edge[i].v);//往下进行延伸,开始递归
LOW[x]=min(LOW[x],LOW[edge[i].v]);//递归出来,比较谁是谁的儿子/父亲,就是树的对应关系,涉及到强连通分量子树最小根的事情。
if (LOW[edge[i].v] > DFN[x])
{
//该部分主要用来处理桥,满足条件x到edge[i].v边为桥
//桥处理操作可以写在这里面
}
}
else if(visit[edge[i].v ]){ //如果访问过,并且还在栈里。
LOW[x]=min(LOW[x],DFN[edge[i].v]);//比较谁是谁的儿子/父亲。就是链接对应关系
}
}
if(LOW[x]==DFN[x]) //发现是整个强连通分量子树里的最小根。
{
cntp++;//这里可以记录强连通图个数
do{
visit[stack[index]]=0;
pa[stack[index]]=cntp; //记录当前节点在哪一个强连通图中
index--;
}while(x!=stack[index+1]);//出栈,并且输出。
}
return ;
}
int main()
{
memset(heads,-1,sizeof(heads));
memset(DFN,0,sizeof(DFN));
memset(vis,0,sizeof(vis));
int n,m;
scanf("%d%d",&n,&m);
int x,y;
for(int i=1;i<=m;i++)
{
scanf("%d%d",&x,&y);
add(x,y);
}
for(int i=1;i<=n;i++)
if(!DFN[i]) tarjan(i);//当这个点没有访问过,就从此点开始。防止图没走完
return 0;
}
kuangbin求强连通图模版
const int MAXN = 20010;//点数
const int MAXM = 50010;//边数
struct Edge{
int to,next;
}edge[MAXM];
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];//Belong 数组的值是 1 ∼ scc
int Index,top;
int scc;//强连通分量的个数
bool Instack[MAXN];
int num[MAXN];//各个强连通分量包含点的个数,数组编号 1 ∼ scc
//num 数组不一定需要,结合实际情况
void addedge(int u,int v){
edge[tot].to = v;edge[tot].next = head[u];head[u] = tot++;
}
void Tarjan(int u){
int v;
Low[u] = DFN[u] = ++Index;
Stack[top++] = u;
Instack[u] = true;
for(int i = head[u];i != -1;i = edge[i].next){
v = edge[i].to;
if( !DFN[v] ){
Tarjan(v);
if( Low[u] > Low[v] )Low[u] = Low[v];
}
else if(Instack[v] && Low[u] > DFN[v])
Low[u] = DFN[v];
}
if(Low[u] == DFN[u]){
scc++;
do{
v = Stack[−−top];
Instack[v] = false;
Belong[v] = scc;
num[scc]++;
}while( v != u);
}
}
void solve(int N){
memset(DFN,0,sizeof(DFN));
memset(Instack,false,sizeof(Instack));
memset(num,0,sizeof(num));
Index = scc = top = 0;
for(int i = 1;i <= N;i++)
if(!DFN[i])
Tarjan(i);
}
void init(){
tot = 0;
memset(head,−1,sizeof(head));
}
kuangbin求割点和桥模版:
/*
* 求无向图的割点和桥
* 可以找出割点和桥,求删掉每个点后增加的连通块
* 需要注意重边的处理,可以先用矩阵存,再转邻接表,或者进行判重
*/
const int MAXN = 10010;
const int MAXM = 100010;
struct Edge{
int to,next;
bool cut;//是否为桥的标记
}edge[MAXM];
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN];
int Index,top;
bool Instack[MAXN];
bool cut[MAXN];
int add_block[MAXN];//删除一个点后增加的连通块
int bridge;
void addedge(int u,int v){
edge[tot].to = v;edge[tot].next = head[u];edge[tot].cut = false ;
head[u] = tot++;
}
void Tarjan(int u,int pre){
int v;
Low[u] = DFN[u] = ++Index;
Stack[top++] = u;
Instack[u] = true;
int son = 0;
int pre_cnt = 0; //处理重边,如果不需要可以去掉
for(int i = head[u];i != -1;i = edge[i].next){
v = edge[i].to;
if(v == pre && pre_cnt == 0){pre_cnt++;continue;}
if( !DFN[v] ){
son++;
Tarjan(v,u);
if(Low[u] > Low[v])Low[u] = Low[v];
//桥
//一条无向边 (u,v) 是桥,当且仅当 (u,v) 为树枝边,且满足 DFS(u)<Low(v)。
if(Low[v] > DFN[u]){
bridge++;
edge[i].cut = true;
edge[i^1].cut = true;
}
//割点
//一个顶点 u 是割点,当且仅当满足 (1) 或 (2) (1) u 为树根,且 u 有多于一个子树
//(2) u 不为树根,且满足存在 (u,v) 为树枝边 (或称父子边,
//即 u 为 v 在搜索树中的父亲),使得 DFS(u)<=Low(v)
if(u != pre && Low[v] >= DFN[u]){//不是树根
cut[u] = true;
add_block[u]++;
}
}
else if( Low[u] > DFN[v])
Low[u] = DFN[v];
}
//树根,分支数大于 1
if(u == pre && son > 1)cut[u] = true;
if(u == pre)add_block[u] = son - 1;
Instack[u] = false;
top--;
}
①图的保存方式使用的是邻接表,可以改为vector数组保存,只需要将add和tarjan函数相应部分改变一下就好
割点
若从图中删除节点 x 以及所有与 x 关联的边之后,图将被分成两个或两个以上的不相连的子图,那么称 x 为图的割点。
桥
若从图中删除边 e 之后,图将分裂成两个不相连的子图,那么称 e 为图的桥或割边。
②tarjan可以用来求图的桥
割点主要操作位置在tarjan函数中
if (LOW[edge[i].v] > DFN[x])
{
//该部分主要用来处理桥,满足条件edge[i].v到x之间为桥
//桥处理操作可以写在这里面
}
将需要对桥进行的操作写在里面即可
③tarjan可以用来求图的割点,使用到kuangbin模版
//桥
//一条无向边 (u,v) 是桥,当且仅当 (u,v) 为树枝边,且满足 DFS(u)<Low(v)。
if(Low[v] > DFN[u]){
bridge++;
edge[i].cut = true;
edge[i^1].cut = true;
}
//割点
//一个顶点 u 是割点,当且仅当满足 (1) 或 (2) (1) u 为树根,且 u 有多于一个子树
//(2) u 不为树根,且满足存在 (u,v) 为树枝边 (或称父子边,
//即 u 为 v 在搜索树中的父亲),使得 DFS(u)<=Low(v)
if(u != pre && Low[v] >= DFN[u]){//不是树根
cut[u] = true;
add_block[u]++;
}
④tarjan判断强连通图的数量和处理各个点所在的强连通图
cntp保存强连通图数量
pa[i]保存i点所在的强连通图
if(LOW[x]==DFN[x]) //发现是整个强连通分量子树里的最小根。
{
cntp++;//这里可以记录强连通图个数
do{
visit[stack[index]]=0;
pa[stack[index]]=cntp; //记录当前节点在哪一个强连通图中
index--;
}while(x!=stack[index+1]);//出栈,并且输出。
}
例题:
①tarjan算法求桥问题
HDU - 4738 Caocao’s Bridges
题目链接
#include<iostream>
#include<cstdio>
#include<string.h>
#include<vector>
#include<string>
#include<math.h>
#include<algorithm>
using namespace std;
const int MAXN = 1100;//点数
const int MAXM = 50010;//边数
#define inf 0x3f3f3f
int n,m;
int cost[MAXN][MAXN];
vector<int> eg[MAXN];
int idx;
int dfn[MAXN],low[MAXN],parent[MAXN],res;
void tarjan(int u)
{
int child = 0;
low[u] = dfn[u] = ++idx;
for (int v : eg[u])
{
if (!dfn[v])
{
parent[v] = u;
tarjan(v);
low[u] = min(low[u], low[v]);
if (low[v] > dfn[u])
{
res=min(res,cost[u][v]);
}
}
else if (v!= parent[u])
low[u]=min(low[u],dfn[v]);
}
}
void init()
{
res = inf;
idx = 0;
memset(dfn,0,sizeof(dfn));
memset(low,0,sizeof(low));
memset(parent,-1,sizeof(parent));
memset(cost,0, sizeof(cost));
}
int main()
{
int n, m, x, y, w;
while (~scanf("%d%d",&n,&m))
{
if(n==0&&m==0)
break;
init();
for (int i = 0; i < m; i++)
{
scanf("%d%d%d",&x,&y,&w);
eg[x].push_back(y);
eg[y].push_back(x);
if (cost[x][y] != 0)
cost[x][y]=cost[y][x]=inf;
else
cost[x][y]=cost[y][x]=w;
}
int i;
tarjan(1);
for (i =2; i <= n; i++)
if(!dfn[i]){ //如果超过两个连通图时
cout<<0<<endl;
break;
}
if (i== n+1)
{
if (res==inf)
cout << -1 << endl;
else if (res == 0)
cout << 1 << endl;
else
cout << res << endl;
}
for(int i=1;i<= n;i++)
eg[i].clear();
}
return 0;
}
②tarjan算法处理强连通图问题
CodeForces - 427C Checkposts
题目链接
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<string.h>
using namespace std;
const int maxn=1e5+10;
const int mod=1e9+7;
#define ll long long
struct node {
int v,next;
}edge[3*maxn];
int pa[maxn],minv[maxn],num[maxn],c[maxn];
int DFN[maxn],LOW[maxn];
int stack[maxn],heads[maxn],visit[maxn],cnt,tot,index,cntp;
void add(int x,int y)
{
edge[++cnt].next=heads[x];
edge[cnt].v = y;
heads[x]=cnt;
return ;
}
void tarjan(int x)//代表第几个点在处理。递归的是点。
{
DFN[x]=LOW[x]=++tot;// 新进点的初始化。
stack[++index]=x;//进站
visit[x]=1;//表示在栈里
for(int i=heads[x];i!=-1;i=edge[i].next)
{
if(!DFN[edge[i].v]) {//如果没访问过
tarjan(edge[i].v);//往下进行延伸,开始递归
LOW[x]=min(LOW[x],LOW[edge[i].v]);//递归出来,比较谁是谁的儿子/父亲,就是树的对应关系,涉及到强连通分量子树最小根的事情。
}
else if(visit[edge[i].v]){ //如果访问过,并且还在栈里。
LOW[x]=min(LOW[x],DFN[edge[i].v]);//比较谁是谁的儿子/父亲。就是链接对应关系
}
}
if(LOW[x]==DFN[x]) //发现是整个强连通分量子树里的最小根。
{
cntp++;//这里可以记录强连通图个数
do{
visit[stack[index]]=0;
pa[stack[index]]=cntp; //记录当前节点在哪一个强连通图中
index--;
}while(x!=stack[index+1]);//出栈,并且输出。
}
return ;
}
int main()
{
memset(heads,-1,sizeof(heads));
int n,m;
scanf("%d",&n);
for(int i=1;i<=n;i++) minv[i]=1e9;
for(int i=1;i<=n;i++)
scanf("%d",&c[i]);
scanf("%d",&m);
int x,y;
for(int i=1;i<=m;i++)
{
scanf("%d%d",&x,&y);
add(x,y);
}
for(int i=1;i<=n;i++)
if(!DFN[i]) tarjan(i);//当这个点没有访问过,就从此点开始。防止图没走完
for(int i=1;i<=n;i++){
minv[pa[i]]=min(minv[pa[i]],c[i]);
}
for(int i=1;i<=n;i++){
if(c[i]==minv[pa[i]]){
num[pa[i]]++;
}
}
ll ans=0;
ll ant=1;
for(int i=1;i<=cntp;i++){
ans+=minv[i];
ant*=num[i];
ant%=mod;
}
cout<<ans<<" "<<ant<<endl;
return 0;
}
HDU3062 Party
题目+讲解