[图论]强联通分量

暂时不知道这玩意怎么用，暂时不知道啥时候用这玩意....

在有向图G中，如果两点互相可达，则称这两个点强连通，如果G中任意两点互相可达，则称G是强连通图。

定理： 1、一个有向图是强连通的，当且仅当G中有一个回路，它至少包含每个节点一次。

            2、非强连通有向图的极大强连通子图，称为强连通分量（SCC即Strongly Connected Componenet）。

怎么求这个强联通分量呢？

Tarjan算法是基于对图深度优先搜索的算法，每个强连通分量为搜索树中的一棵子树。总的来说， Tarjan算法基于一个观察，即：同处于一个SCC中的结点必然构成DFS树的一棵子树。 我们要找SCC，就得找到它在DFS树上的根。

-----------------------------------------------------------------------------------

tin[u]代表访问u节点的时间戳，low[u]代表u为根节点的dfs树中时间戳最小的顶点的时间戳。

访问到u时，tin[u]=low[u]=++id;

u入栈。

由u的顶点找下点v。若v未访问过，dfs(v);　　low[u]=min(low[u],low[v]);

若v已经访问过，则说明形成了环， low[u]=min(low[u],tin[v]);

若tin[u]==low[u] 则开始出栈，一直出到u。其中 用belong数组来记录这个点属于的块。

void tarjan(int u)
{
    tin[u]=low[u]=++id;
    s.push(u);
    bok[u]=1;
    for(int i=Link[u];i;i=e[i].next)
    {
        int v=e[i].y;
        if(!tin[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(bok[v])
        {
            low[u]=min(low[u],tin[v]);
        }
    }
    if(tin[u]==low[u])
    {
        Bcnt++;
        while(true)
        {
            int v=s.top();
            s.pop();
            bok[v]=0;
            belong[v]=Bcnt;
            if(u==v)    break;
        }
    }
}

for(int i=1;i<=n;i++)
            if(!tin[i])
                tarjan(i);
        int f=1;
        for(int i=1;i<=n;i++)
            if(belong[i]!=1)
                f=0;
        if(f)   printf("Yes
");
        else    printf("No
");

边双联通分量：在求有向图的强联通分量时，只要不走父边，就是边联通分量。

void tarjan(int u,int fa)
{
    tin[u]=low[u]=++id;
    s.push(u);
    bok[u]=1;
    for(int i=Link[u];i;i=e[i].next)
    {
        int v=e[i].y;
        if(v==fa)   continue;
        if(!tin[v])
        {
            tarjan(v,u);
            low[u]=min(low[u],low[v]);
        }
        else if(bok[v])
        {
            low[u]=min(low[u],tin[v]);
        }
    }
    if(tin[u]==low[u])
    {
        Bcnt++;
        while(true)
        {
            int v=s.top();
            s.pop();
            bok[v]=0;
            belong[v]=Bcnt;
            if(u==v)    break;
        }
    }
}

 点双联通分量

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector> 
#include <stack>

using namespace std;

const int maxn = 105, maxm = maxn * 2;

int n, m, tot, dfs_clock, bcc_cnt;

int h[maxn], dfn[maxn], low[maxn], iscut[maxn], bccno[maxn];

vector<int> bcc[maxn];
 
struct edge1
{
    int v, next;
}a[maxm];

struct EDGE
{
    int u, v;
};

stack<EDGE> s;

void add(int x, int y)
{
    a[tot].v = y;
    a[tot].next = h[x];
    h[x] = tot++;
}

int dfs(int u, int fa)
{
    int lowu = dfn[u] = ++dfs_clock;
    int child = 0;
    for (int i = h[u]; ~i; i = a[i].next)
    {
        int v = a[i].v;
        EDGE e = (EDGE){u, v};//所谓栈中存储的是边
        if (!dfn[v])
        {
            s.push(e);//把沿途遍历到的边都加入栈
            child++;
            int lowv = dfs(v, u);
            lowu = min(lowu, lowv);
            if (lowv >= dfn[u])
            {
                iscut[u] = 1;//我们发现了一个割顶，也就说明当前栈中已经保存了一个点双的集合。
                bcc_cnt++;//bcc_cnt从1开始。
                bcc[bcc_cnt].clear();//应付多组数据，应该先清空。
                for(;;)
                {
                    EDGE x = s.top(); s.pop();
                    if (bccno[x.u] != bcc_cnt)
                    {
                        bcc[bcc_cnt].push_back(x.u);
                        bccno[x.u] = bcc_cnt;
                    }
                    if (bccno[x.v] != bcc_cnt)
                    {
                        bcc[bcc_cnt].push_back(x.v);
                        bccno[x.v] = bcc_cnt;
                    }//这两段的意思是，把边集中涉及到的点全部取出来，把他们的bccno[]设置成当前的bcc_cnt
                    if (x.u == u && x.v == v) break;//一直弹栈直到弹到了当前加入的边，break。
                }
            }
        }else if (dfn[v] < dfn[u] && v != fa)
        {
            s.push(e);//把沿途遍历到的边都加入栈。
            lowu = min(lowu, dfn[v]);
        }
    }
    if (fa == 0 && child == 1)
    {
        iscut[u] = 0;
    }
    low[u] = lowu;
    return lowu;
}

int main()
{
    freopen("无向图的点双联通分量.in","r",stdin);
    scanf("%d%d", &n, &m);
    memset(h, -1, sizeof h); tot = dfs_clock = bcc_cnt = 0;
    for (int i = 1; i <= m; i++)
    {
        int x, y;
        scanf("%d%d", &x, &y);
        add(x, y); add(y, x);
    }
    dfs(1, 0);
    for (int i = 1; i <= bcc_cnt; i++)
    {
        for (int j = 0; j < bcc[i].size(); j++)
            printf("%d ", bcc[i][j]);
        printf("
");
    }
    return 0;
}#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector> 
#include <stack>

using namespace std;

const int maxn = 105, maxm = maxn * 2;

int n, m, tot, dfs_clock, bcc_cnt;

int h[maxn], dfn[maxn], low[maxn], iscut[maxn], bccno[maxn];

vector<int> bcc[maxn];
 
struct edge1
{
    int v, next;
}a[maxm];

struct EDGE
{
    int u, v;
};

stack<EDGE> s;

void add(int x, int y)
{
    a[tot].v = y;
    a[tot].next = h[x];
    h[x] = tot++;
}

int dfs(int u, int fa)
{
    int lowu = dfn[u] = ++dfs_clock;
    int child = 0;
    for (int i = h[u]; ~i; i = a[i].next)
    {
        int v = a[i].v;
        EDGE e = (EDGE){u, v};//所谓栈中存储的是边
        if (!dfn[v])
        {
            s.push(e);//把沿途遍历到的边都加入栈
            child++;
            int lowv = dfs(v, u);
            lowu = min(lowu, lowv);
            if (lowv >= dfn[u])
            {
                iscut[u] = 1;//我们发现了一个割顶，也就说明当前栈中已经保存了一个点双的集合。
                bcc_cnt++;//bcc_cnt从1开始。
                bcc[bcc_cnt].clear();//应付多组数据，应该先清空。
                for(;;)
                {
                    EDGE x = s.top(); s.pop();
                    if (bccno[x.u] != bcc_cnt)
                    {
                        bcc[bcc_cnt].push_back(x.u);
                        bccno[x.u] = bcc_cnt;
                    }
                    if (bccno[x.v] != bcc_cnt)
                    {
                        bcc[bcc_cnt].push_back(x.v);
                        bccno[x.v] = bcc_cnt;
                    }//这两段的意思是，把边集中涉及到的点全部取出来，把他们的bccno[]设置成当前的bcc_cnt
                    if (x.u == u && x.v == v) break;//一直弹栈直到弹到了当前加入的边，break。
                }
            }
        }else if (dfn[v] < dfn[u] && v != fa)
        {
            s.push(e);//把沿途遍历到的边都加入栈。
            lowu = min(lowu, dfn[v]);
        }
    }
    if (fa == 0 && child == 1)
    {
        iscut[u] = 0;
    }
    low[u] = lowu;
    return lowu;
}

int main()
{
    freopen("无向图的点双联通分量.in","r",stdin);
    scanf("%d%d", &n, &m);
    memset(h, -1, sizeof h); tot = dfs_clock = bcc_cnt = 0;
    for (int i = 1; i <= m; i++)
    {
        int x, y;
        scanf("%d%d", &x, &y);
        add(x, y); add(y, x);
    }
    dfs(1, 0);
    for (int i = 1; i <= bcc_cnt; i++)
    {
        for (int j = 0; j < bcc[i].size(); j++)
            printf("%d ", bcc[i][j]);
        printf("
");
    }
    return 0;
}