圖->連通性->有向圖的強連通分量

 

 文字描述

　　有向圖強連通分量的定義：在有向圖G中，如果兩個頂點vi,vj間（vi>vj）有一條從vi到vj的有向路徑，同時還有一條從vj到vi的有向路徑，則稱兩個頂點強連通(strongly connected)。如果有向圖G的每兩個頂點都強連通，稱G是一個強連通圖。有向圖的極大強連通子圖，稱為強連通分量(strongly connected components)。

　　用深度優先搜索求有向圖的強連通分量的方法如下並假設有向圖的存儲結構為十字鏈表。

　　1 在有向圖G上，從某個定點出發沿以該頂點為尾的弧進行深度優先遍歷；並按其所有鄰接點的搜索都完成(即退出DFS函數)的順序將頂點排列起來。此時需對之前的深度優先遍歷算法(見圖遍歷)作兩處修改: (a)在進入DSFTraverse函數時首先進行計數變量的初始化，即在入口處加上count=0;(b)在退出DFS函數之前將完成搜索的頂點號記錄在另一個輔助數組finished[vexnum]中，即在DFS函數結束之前加上finished[count++]=v；

　　2 在有向圖G上，從最后完成搜索的頂點(即finished[count-1])出發，沿着以該頂點為頭的弧作逆向的深度優先搜索遍歷，若遍歷不能訪問到有向圖中所有頂點，則從余下的頂點中最后完搜索的那個頂點出發，繼續作逆向的深度優先搜索便利。依次類推。

　　由此，每一次調用DFS作逆向深度優先遍歷所訪問到的頂點集便是有向圖G中一個強連通分量的頂點集。

 

示意圖

見本章后面的代碼運行Example01, Example02, Example03, Example04。

 

算法分析

求有向圖的強連通分量的算法時間復雜度和深度優先搜索遍歷相同。

 

代碼實現

 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define    MAX_VERTEX_NUM    20
#define    DEBUG
#ifdef DEBUG
#include <stdarg.h>
#define LOG(args...) _log_(__FILE__, __FUNCTION__, __LINE__, ##args);
void _log_(const char *file, const char *function, int line, const char * format, ...)
{
    char buf[1024] = {0};
    va_list list;
    va_start(list, format);
    sprintf(buf, "[%s,%s,%d]", file, function, line);
    vsprintf(buf+strlen(buf), format, list);
    sprintf(buf+strlen(buf), "\n");
    va_end(list);
    printf(buf);
}
#else
#define LOG
#endif // DEBUG

//////////////////////////////////////////////////////////////
// 十字鏈表作為圖的存儲結構
//////////////////////////////////////////////////////////////
typedef enum {DG, DN, UDG, UDN} GraphKind;
typedef char InfoType;
typedef char VertexType;
typedef struct ArcBox{
    int tailvex, headvex;
    struct ArcBox *hlink, *tlink;
    InfoType *info;
}ArcBox;
typedef struct VexNode{
    VertexType data;
    ArcBox *firstin, *firstout;
}VexNode;
typedef struct{
    VexNode xlist[MAX_VERTEX_NUM];
    int vexnum, arcnum;
    GraphKind kind;
}OLGraph;

//////////////////////////////////////////////////////////////
// 若G中存在頂點u，則返回該頂點在圖中位置；否則返回-1。
//////////////////////////////////////////////////////////////
int LocateVex(OLGraph G, VertexType v)
{
    int i = 0;
    for(i=0; i<G.vexnum; i++)
    {
        if(G.xlist[i].data == v)
            return i;
    }
    return -1;
}

//////////////////////////////////////////////////////////////
// 若G中存在頂點位置loc存在,則返回其頂點名稱
//////////////////////////////////////////////////////////////
VertexType LocateVInfo(OLGraph G, int loc)
{
    return G.xlist[loc].data;
}


//////////////////////////////////////////////////////////////
// 以十字鏈表作為圖的存儲結構創建有向圖
//////////////////////////////////////////////////////////////
int CreateDG(OLGraph *G)
{
    printf("\n以十字鏈表作為圖的存儲結構創建有向圖:\n");
    int i = 0, j = 0, k = 0, IncInfo = 0;
    int v1 = 0, v2 = 0;
    char tmp[10] = {0};
    ArcBox *p = NULL;
    printf("輸入頂點數，弧數，其他信息標志位: ");
    scanf("%d,%d,%d", &G->vexnum, &G->arcnum, &IncInfo);
    for(i=0; i<G->vexnum; i++)
    {
        //輸入頂點值
        printf("輸入第%d個頂點: ", i+1);
        memset(tmp, 0, sizeof(tmp));
        scanf("%s", tmp);
        //初始化指針
        G->xlist[i].data = tmp[0];
        G->xlist[i].firstin = NULL;
        G->xlist[i].firstout = NULL;
    }
    //輸入各弧並構造十字鏈表
    for(k=0; k<G->arcnum; k++)
    {
        printf("輸入第%d條弧(頂點1, 頂點2): ", k+1);
        memset(tmp, 0, sizeof(tmp));
        scanf("%s", tmp);
        sscanf(tmp, "%c,%c", &v1, &v2);
        i = LocateVex(*G, v1);
        j = LocateVex(*G, v2);
        //對弧結點賦值
        p = (ArcBox *) malloc(sizeof(ArcBox));
        p->tailvex = i;
        p->headvex = j;
        p->hlink = G->xlist[j].firstin;
        p->tlink = G->xlist[i].firstout;
        p->info = NULL;
        //完成在入弧和出弧鏈頭的插入
        G->xlist[j].firstin = p;
        G->xlist[i].firstout = p;
        //若弧有相關的信息,則輸入
        if(IncInfo)
        {
            //Input(p->info);
        }
    }
    return 0;
}

int CreateGraph(OLGraph *G)
{
    printf("輸入圖類型: +有向圖(0), -有向網(1), -無向圖(2), -無向網(3): ");
    scanf("%d", &G->kind);
    switch(G->kind){
        case DG:
            return CreateDG(G);
        case DN:
        case UDN:
        case UDG:
        default:
            printf("not support!\n");
            return -1;
    }
    return 0;
}

//////////////////////////////////////////////////////////////
// 打印圖結點
//////////////////////////////////////////////////////////////
void printG(OLGraph G)
{
    printf("\n打印圖結點\n");
    if(G.kind == DG){
        printf("類型：有向圖；頂點數 %d, 弧數 %d\n", G.vexnum, G.arcnum);
    }else if(G.kind == DN){
        printf("類型：有向網；頂點數 %d, 弧數 %d\n", G.vexnum, G.arcnum);
    }else if(G.kind == UDG){
        printf("類型：無向圖；頂點數 %d, 弧數 %d\n", G.vexnum, G.arcnum);
    }else if(G.kind == UDN){
        printf("類型：無向網；頂點數 %d, 弧數 %d\n", G.vexnum, G.arcnum);
    }
    int i = 0;
    ArcBox *fi = NULL;
    ArcBox *fo = NULL;
    for(i=0; i<G.vexnum; i++)
    {
        printf("%c: ", G.xlist[i].data);
        fi = G.xlist[i].firstin;
        fo = G.xlist[i].firstout;
        printf("{hlink=");
        while(fi)
        {
            printf("(%d,%c)->(%d,%c); ", fi->tailvex, LocateVInfo(G, fi->tailvex), fi->headvex, LocateVInfo(G, fi->headvex));
            fi = fi->hlink;
        }
        printf("}        {tlink=");
        while(fo)
        {
            printf("(%d,%c)->(%d,%c); ", fo->tailvex, LocateVInfo(G, fo->tailvex), fo->headvex, LocateVInfo(G, fo->headvex));
            fo = fo->tlink;
        }
        printf("}\n");
    }
    return ;
}



//////////////////////////////////////////////////////////////
// 用雙向遍歷的方法求有向圖的強連通分量
//////////////////////////////////////////////////////////////
int GVisited[MAX_VERTEX_NUM] = {0};
void (*visitfun)(OLGraph G, int v);

//記錄退出DFS函數之前完成搜索的頂點號
int GFinished[MAX_VERTEX_NUM] = {0};
int GCount = 0;

#define D_OUT 0
#define D_IN  1
typedef enum DIRECTION
{
    IN,
    OUT
}DIRECTION;

//////////////////////////////////////////////////////////////
// 打印結點在圖中的位置及結點信息
//////////////////////////////////////////////////////////////
void printvex(OLGraph G, int v)
{
    printf("[%d]:%c\t", v, G.xlist[v].data);
    return ;
}

//////////////////////////////////////////////////////////////
// direction is IN: 返回圖G中以頂點位置為V的頂點為入度的第一個結點
// direction is OUT: 返回圖G中以頂點位置為V的頂點為出度的第一個結點
//////////////////////////////////////////////////////////////
int FirstAdjVex(OLGraph G, int v, int direction)
{
    if(direction == IN){
        return (G.xlist[v].firstin)?G.xlist[v].firstin->tailvex:-1;
    }else if(direction == OUT){
        return (G.xlist[v].firstout)?G.xlist[v].firstout->headvex:-1;
    }else{
        return -1;
    }
}

//////////////////////////////////////////////////////////////
// direction is IN: G中位置w是以v為入度的結點， 返回下一個以v為入度的結點
// direction is OUT: G中位置w是以v為出度的結點， 返回下一個以v為出度的結點
//////////////////////////////////////////////////////////////
int NextAdjVex(OLGraph G, int v, int w, int direction)
{
    int ret = -1;
    if(direction == IN){
        ArcBox *fi = NULL;
        fi = G.xlist[v].firstin;
        while(fi)
        {
            if(fi->tailvex == w)
                break;
            fi = fi->hlink;
        }
        if(fi && (fi=fi->hlink)){
            ret = fi->tailvex;
        }else{
            ret = -1;
        }
    }else if(direction == OUT){
        ArcBox *fo = NULL;
        fo = G.xlist[v].firstout;
        while(fo)
        {
            if(fo->headvex == w)
                break;
            fo = fo->tlink;
        }
        if(fo && (fo=fo->tlink)){
            ret = fo->headvex;
        }else{
            ret = -1;
        }
    }
    return ret;
}
//////////////////////////////////////////////////////////////
// direction is IN :從第v個頂點出發, 沿着以v為入度的頂點的方式, 遞歸地深度優先遍歷圖G
// direction is OUT :從第v個頂點出發, 沿着以v為出度的頂點的方式, 遞歸地深度優先遍歷圖G
//////////////////////////////////////////////////////////////
void DFS(OLGraph G, int v, int direction)
{
    GVisited[v] = 1;
    printvex(G, v);
    int w = 0;
    for(w=FirstAdjVex(G,v,direction); w>=0; w=NextAdjVex(G, v, w, direction))
    {
        if(!GVisited[w]){
            DFS(G, w, direction);
        }
    }
    GFinished[GCount++] = v;
}

//////////////////////////////////////////////////////////////
// 1 從第一個出發,對圖G作深度優先遍歷並記錄下退出DFS函數的順序
// 2 從最后一個退出DFS函數的頂點出發， 反方向對圖G作深度優先遍歷並求出圖的強連通分量
//////////////////////////////////////////////////////////////
void DFSTraverse(OLGraph G, void (*visitfun)(OLGraph G, int v))
{
    visitfun = printvex;
    int v = 0;
    int index = 0;

    printf("\n深度優先搜索(以第一個頂點為尾的弧進行深度優先搜索遍歷):\n");
    //訪問標志數組初始化
    for(v=0; v<G.vexnum; v++)
    {
        GVisited[v] = 0;
        GFinished[v] = 0;
    }
    GCount = 0;

    for(v=0; v<G.vexnum; v++)
    {
        if(!GVisited[v]){
            DFS(G, v, OUT);
        }
    }

    printf("\n退出DFS函數的次序location和頂點位置index為:\n");
    for(v=0; v<GCount; v++)
    {
        printf("[location:%d, index:%d] ", v, GFinished[v]);
    }
    printf("\n");

    printf("深度優先搜索(從最后完成搜索的頂點出發，沿着以該頂點為頭的弧作逆向的深度優先搜索遍歷):");
    //訪問標志數組初始化
    for(v=0; v<G.vexnum; v++)
    {
        GVisited[v] = 0;
    }
    for(v=0; v<GCount; v++)
    {
        index = GFinished[GCount-1-v];
        if(!GVisited[index]){
            printf("\n強連通分量:");
            DFS(G, index, IN);
        }
    }
    printf("\n");
}


int main(int argc, char *argv[])
{
    OLGraph G;
    if(CreateGraph(&G) > -1){
        printG(G);
    }
    DFSTraverse(G, printvex);
}

 

代碼運行

Example01

 

 

[jennifer@localhost Data.Structure]$ ./a.out 
輸入圖類型: +有向圖(0), -有向網(1), -無向圖(2), -無向網(3): 0

以十字鏈表作為圖的存儲結構創建有向圖:
輸入頂點數，弧數，其他信息標志位: 4,7,0
輸入第1個頂點: a
輸入第2個頂點: b
輸入第3個頂點: c
輸入第4個頂點: d
輸入第1條弧(頂點1, 頂點2): a,b
輸入第2條弧(頂點1, 頂點2): a,c
輸入第3條弧(頂點1, 頂點2): c,a
輸入第4條弧(頂點1, 頂點2): c,d
輸入第5條弧(頂點1, 頂點2): d,c
輸入第6條弧(頂點1, 頂點2): d,a
輸入第7條弧(頂點1, 頂點2): d,b

打印圖結點
類型：有向圖；頂點數 4, 弧數 7
a: {hlink=(3,d)->(0,a); (2,c)->(0,a); }        {tlink=(0,a)->(2,c); (0,a)->(1,b); }
b: {hlink=(3,d)->(1,b); (0,a)->(1,b); }        {tlink=}
c: {hlink=(3,d)->(2,c); (0,a)->(2,c); }        {tlink=(2,c)->(3,d); (2,c)->(0,a); }
d: {hlink=(2,c)->(3,d); }        {tlink=(3,d)->(1,b); (3,d)->(0,a); (3,d)->(2,c); }

深度優先搜索(以第一個頂點為尾的弧進行深度優先搜索遍歷):
[0]:a    [2]:c    [3]:d    [1]:b    
退出DFS函數的次序location和頂點位置index為:
[location:0, index:1] [location:1, index:3] [location:2, index:2] [location:3, index:0] 
深度優先搜索(從最后完成搜索的頂點出發，沿着以該頂點為頭的弧作逆向的深度優先搜索遍歷):
強連通分量:[0]:a    [3]:d    [2]:c    
強連通分量:[1]:b    
[jennifer@localhost Data.Structure]$ 

 

Example02

 

 

[jennifer@localhost blogs]$ ./a.out 
輸入圖類型: +有向圖(0), -有向網(1), -無向圖(2), -無向網(3): 0

以十字鏈表作為圖的存儲結構創建有向圖:
輸入頂點數，弧數，其他信息標志位: 6,8,0
輸入第1個頂點: 1
輸入第2個頂點: 2
輸入第3個頂點: 3
輸入第4個頂點: 4
輸入第5個頂點: 5
輸入第6個頂點: 6
輸入第1條弧(頂點1, 頂點2): 1,2
輸入第2條弧(頂點1, 頂點2): 1,3
輸入第3條弧(頂點1, 頂點2): 2,4
輸入第4條弧(頂點1, 頂點2): 3,4
輸入第5條弧(頂點1, 頂點2): 3,5
輸入第6條弧(頂點1, 頂點2): 4,1
輸入第7條弧(頂點1, 頂點2): 4,7
輸入第8條弧(頂點1, 頂點2): 5,6

打印圖結點
類型：有向圖；頂點數 6, 弧數 8
1: {hlink=(3,4)->(0,1); }        {tlink=(0,1)->(2,3); (0,1)->(1,2); }
2: {hlink=(0,1)->(1,2); }        {tlink=(1,2)->(3,4); }
3: {hlink=(0,1)->(2,3); }        {tlink=(2,3)->(4,5); (2,3)->(3,4); }
4: {hlink=(2,3)->(3,4); (1,2)->(3,4); }        {tlink=(3,4)->(-1,<); (3,4)->(0,1); }
5: {hlink=(2,3)->(4,5); }        {tlink=(4,5)->(5,6); }
6: {hlink=(4,5)->(5,6); }        {tlink=}

深度優先搜索(以第一個頂點為尾的弧進行深度優先搜索遍歷):
[0]:1    [2]:3    [4]:5    [5]:6    [3]:4    [1]:2    
退出DFS函數的次序location和頂點位置index為:
[location:0, index:5] [location:1, index:4] [location:2, index:3] [location:3, index:2] [location:4, index:1] [location:5, index:0] 
深度優先搜索(從最后完成搜索的頂點出發，沿着以該頂點為頭的弧作逆向的深度優先搜索遍歷):
強連通分量:[0]:1    [3]:4    [2]:3    [1]:2    
強連通分量:[4]:5    
強連通分量:[5]:6    
[jennifer@localhost blogs]$ 

 

 

Example03

 

[jennifer@localhost blogs]$ ./a.out 
輸入圖類型: +有向圖(0), -有向網(1), -無向圖(2), -無向網(3): 0

以十字鏈表作為圖的存儲結構創建有向圖:
輸入頂點數，弧數，其他信息標志位: 8,13,0
輸入第1個頂點: a
輸入第2個頂點: b
輸入第3個頂點: c
輸入第4個頂點: d
輸入第5個頂點: e
輸入第6個頂點: f
輸入第7個頂點: g
輸入第8個頂點: h
輸入第1條弧(頂點1, 頂點2): a,b
輸入第2條弧(頂點1, 頂點2): b,c
輸入第3條弧(頂點1, 頂點2): d,c
輸入第4條弧(頂點1, 頂點2): c,d
輸入第5條弧(頂點1, 頂點2): e,a
輸入第6條弧(頂點1, 頂點2): b,e
輸入第7條弧(頂點1, 頂點2): b,f
輸入第8條弧(頂點1, 頂點2): c,g
輸入第9條弧(頂點1, 頂點2): h,d
輸入第10條弧(頂點1, 頂點2): e,f
輸入第11條弧(頂點1, 頂點2): g,f
輸入第12條弧(頂點1, 頂點2): f,g
輸入第13條弧(頂點1, 頂點2): h,g

打印圖結點
類型：有向圖；頂點數 8, 弧數 13
a: {hlink=(4,e)->(0,a); }        {tlink=(0,a)->(1,b); }
b: {hlink=(0,a)->(1,b); }        {tlink=(1,b)->(5,f); (1,b)->(4,e); (1,b)->(2,c); }
c: {hlink=(3,d)->(2,c); (1,b)->(2,c); }        {tlink=(2,c)->(6,g); (2,c)->(3,d); }
d: {hlink=(7,h)->(3,d); (2,c)->(3,d); }        {tlink=(3,d)->(2,c); }
e: {hlink=(1,b)->(4,e); }        {tlink=(4,e)->(5,f); (4,e)->(0,a); }
f: {hlink=(6,g)->(5,f); (4,e)->(5,f); (1,b)->(5,f); }        {tlink=(5,f)->(6,g); }
g: {hlink=(7,h)->(6,g); (5,f)->(6,g); (2,c)->(6,g); }        {tlink=(6,g)->(5,f); }
h: {hlink=}        {tlink=(7,h)->(6,g); (7,h)->(3,d); }

深度優先搜索(以第一個頂點為尾的弧進行深度優先搜索遍歷):
[0]:a    [1]:b    [5]:f    [6]:g    [4]:e    [2]:c    [3]:d    [7]:h    
退出DFS函數的次序location和頂點位置index為:
[location:0, index:6] [location:1, index:5] [location:2, index:4] [location:3, index:3] [location:4, index:2] [location:5, index:1] [location:6, index:0] [location:7, index:7] 
深度優先搜索(從最后完成搜索的頂點出發，沿着以該頂點為頭的弧作逆向的深度優先搜索遍歷):
強連通分量:[7]:h    
強連通分量:[0]:a    [4]:e    [1]:b    
強連通分量:[2]:c    [3]:d    
強連通分量:[5]:f    [6]:g    
[jennifer@localhost blogs]$ 

 

 

Example04

 

[jennifer@localhost blogs]$ ./a.out 
輸入圖類型: +有向圖(0), -有向網(1), -無向圖(2), -無向網(3): 0

以十字鏈表作為圖的存儲結構創建有向圖:
輸入頂點數，弧數，其他信息標志位: 10,15
輸入第1個頂點: ^C
[jennifer@localhost blogs]$ ./a.out 
輸入圖類型: +有向圖(0), -有向網(1), -無向圖(2), -無向網(3): 0

以十字鏈表作為圖的存儲結構創建有向圖:
輸入頂點數，弧數，其他信息標志位: 10,15,0
輸入第1個頂點: 0
輸入第2個頂點: 1
輸入第3個頂點: 2
輸入第4個頂點: 3
輸入第5個頂點: 4
輸入第6個頂點: 5
輸入第7個頂點: 6
輸入第8個頂點: 7
輸入第9個頂點: 8
輸入第10個頂點: 9
輸入第1條弧(頂點1, 頂點2): 9,2
輸入第2條弧(頂點1, 頂點2): 7,9
輸入第3條弧(頂點1, 頂點2): 2,7
輸入第4條弧(頂點1, 頂點2): 2,1
輸入第5條弧(頂點1, 頂點2): 2,4
輸入第6條弧(頂點1, 頂點2): 7,4
輸入第7條弧(頂點1, 頂點2): 1,8
輸入第8條弧(頂點1, 頂點2): 0,1
輸入第9條弧(頂點1, 頂點2): 1,0
輸入第10條弧(頂點1, 頂點2): 0,4
輸入第11條弧(頂點1, 頂點2): 8,5
輸入第12條弧(頂點1, 頂點2): 5,0
輸入第13條弧(頂點1, 頂點2): 4,3
輸入第14條弧(頂點1, 頂點2): 3,4
輸入第15條弧(頂點1, 頂點2): 5,6

打印圖結點
類型：有向圖；頂點數 10, 弧數 15
0: {hlink=(5,5)->(0,0); (1,1)->(0,0); }        {tlink=(0,0)->(4,4); (0,0)->(1,1); }
1: {hlink=(0,0)->(1,1); (2,2)->(1,1); }        {tlink=(1,1)->(0,0); (1,1)->(8,8); }
2: {hlink=(9,9)->(2,2); }        {tlink=(2,2)->(4,4); (2,2)->(1,1); (2,2)->(7,7); }
3: {hlink=(4,4)->(3,3); }        {tlink=(3,3)->(4,4); }
4: {hlink=(3,3)->(4,4); (0,0)->(4,4); (7,7)->(4,4); (2,2)->(4,4); }        {tlink=(4,4)->(3,3); }
5: {hlink=(8,8)->(5,5); }        {tlink=(5,5)->(6,6); (5,5)->(0,0); }
6: {hlink=(5,5)->(6,6); }        {tlink=}
7: {hlink=(2,2)->(7,7); }        {tlink=(7,7)->(4,4); (7,7)->(9,9); }
8: {hlink=(1,1)->(8,8); }        {tlink=(8,8)->(5,5); }
9: {hlink=(7,7)->(9,9); }        {tlink=(9,9)->(2,2); }

深度優先搜索(以第一個頂點為尾的弧進行深度優先搜索遍歷):
[0]:0    [4]:4    [3]:3    [1]:1    [8]:8    [5]:5    [6]:6    [2]:2    [7]:7    [9]:9    
退出DFS函數的次序location和頂點位置index為:
[location:0, index:3] [location:1, index:4] [location:2, index:6] [location:3, index:5] [location:4, index:8] [location:5, index:1] [location:6, index:0] [location:7, index:9] [location:8, index:7] [location:9, index:2] 
深度優先搜索(從最后完成搜索的頂點出發，沿着以該頂點為頭的弧作逆向的深度優先搜索遍歷):
強連通分量:[2]:2    [9]:9    [7]:7    
強連通分量:[0]:0    [5]:5    [8]:8    [1]:1    
強連通分量:[6]:6    
強連通分量:[4]:4    [3]:3    
[jennifer@localhost blogs]$