tarjan算法总结

概念(有向图中):

1)在有向图G中,如果两个顶点间至少存在一条路径,称两个顶点强连通

2)如果有向图G的每两个顶点都强连通,则称G是一个强连通图

3)非强连通图有向图的极大强连通子图,称为强连通分量


tarjan算法:通过递归和栈操作,找强连通子图,并进行缩点

设每个点的DFS序为dfn[u],当递归到第u个点,发现下一个点v已经被遍历过,且dfn[u]


然后可以用low[u]记录u所在强连通子图中最小的DFS序,对于每个强连通子图,把点都缩为DFS序最小的那个点(即low[u])


缩点方法:进行递归,每次进入函数时都将当前点入栈,每次退出函数时判断当前点u的DFS序是否为u所在强连通子图中的最小DFS序,即dfn[u]==low[u]。如果是,那么就可以将栈中u之后的点全部缩为点u(可以通过vector实现)


#include
using namespace std;
const int MX = 1e3 + 5;
stackst;                // 存储已遍历的结点
int dfn[MX];                 // 深度优先搜索访问次序
int low[MX];                 // 能追溯到的最早的次序
int mark[MX];                // 检查是否在栈中(2为在栈中,1为已访问,且不在栈中,0为不在)
vector ver[MX];         // 获得强连通分量结果
int id[MX];                  // 记录每个点在第几号强连通分量里
int index, sz;               // DFS序,强连通分量个数
struct Edge {
    int v, nxt;
} E[MX*MX];
int head[MX], tot;

void add(int u, int v) {
    E[tot].v = v;
    E[tot].nxt = head[u];
    head[u] = tot++;
}
void init(int n) {
    while (!st.empty()) st.pop();
    memset(dfn, 0, sizeof(dfn));
    memset(low, 0, sizeof(low));
    for (int i = 1; i <= n; ++ i) ver[i].clear();
    index = sz = 0;
    memset(head, -1, sizeof(head));
    tot = 0;
}

void tarjan(int u) {
    mark[u] = 2;
    low[u] = dfn[u] = ++ index;
    st.push(u);
    for (int i = head[u]; ~i; i = E[i].nxt) {
        int v = E[i].v;
        if (dfn[v] == 0) {
            tarjan(v);
            low[u] = min(low[u], low[v]);
        } else if (mark[v] == 2) low[u] = min(low[u], dfn[v]);
    }
    if (low[u] == dfn[u]) {
        ++ sz;
        while (!st.empty()) {
            int v = st.top();
            st.pop();
            mark[v] = 1;
            ver[sz].push_back(v);
            id[v] = sz;
            if (v == u) break;
        }
    }
}
void solve(int n){
    for(int i=1;i<=n;i++) if(!dfn[i]) tarjan(i);
}

int main() {
    int n, m;
    scanf("%d%d", &n, &m);
    init(n);
    for (int i = 1; i <= m; i++) {
        int u, v;
        scanf("%d%d", &u, &v);
        add(u, v);
    }
    solve(n);
    printf("%d\n", sz);
    return 0;
}


你可能感兴趣的:(tarjan)