數據結構學習筆記05圖 (鄰接矩陣 鄰接表-->BFS DFS、最短路徑)

數據結構之圖

圖(Graph)

包含
　　一組頂點：通常用V (Vertex) 表示頂點集合
　　一組邊：通常用E (Edge) 表示邊的集合
　　　　邊是頂點對：(v, w) ∈E ，其中v, w ∈ V
　　　　有向邊<v, w> 表示從v指向w的邊（單行線）
　　　　不考慮重邊和自回路

無向圖：邊是無向邊(v, w)

有向圖：邊是有向邊<v, w>

連通：如果從V到W存在一條（無向）路徑，則稱V和W是連通的

連通圖(Connected Graph)：如果對於圖的任一兩個頂點v、w∈V，v和w都是連通的，則稱該圖為連通圖。圖中任意兩頂點均連通。

連通分量(Connected Component):無向圖中的極大連通子圖。

　　極大頂點數：再加1個頂點就不連通了
　　極大邊數：包含子圖中所有頂點相連的所有邊

強連通：有向圖中頂點V和W之間存在雙向路徑，則稱V和W是強連通的。
強連通圖：有向圖中任意兩頂點均強連通。
強連通分量：有向圖的極大強連通子圖。

路徑：V到W的路徑是一系列頂點{V, v1, v2, …,vn, W}的集合，其中任一對相鄰的頂點間都有圖中的邊。路徑的長度是路徑中的邊數（如果帶權，則是所有邊的權重和）。

　　　如果V到W之間的所有頂點都不同，則稱簡單路徑
回路：起點等於終點的路徑

　　

一.鄰接矩陣

圖的鄰接矩陣存儲方式就是用一個二維數組來表示。

鄰接矩陣G[N][N]——N個頂點從0到N-1編號

頂點i、j有邊，則G[i][j] = 1 或邊的權重

　　

鄰接矩陣的優點

　　直觀、簡單、好理解
　　方便檢查任意一對頂點間是否存在邊
　　方便找任一頂點的所有“鄰接點”（有邊直接相連的頂點）
　　方便計算任一頂點的“度”（從該點發出的邊數為“出度”，指向該點的邊數為“入度”）
　　無向圖：對應行（或列）非0元素的個數
　　有向圖：對應行非0元素的個數是“出度”；對應列非0元素的個數是“入度”

鄰接矩陣的缺點

　　浪費空間—— 存稀疏圖（點很多而邊很少）有大量無效元素
　　　　對稠密圖（特別是完全圖）還是很合算的
　　　　浪費時間—— 統計稀疏圖中一共有多少條邊

/* ͼµÄÁÚ½Ó¾ØÕó±íʾ·¨ */
#include <iostream>
#include <cstdio>
#include <cstdlib> 
#include <queue>
using namespace std;

#define MaxVertexNum 100    /* ×î´ó¶¥µãÊýÉèΪ100 */
#define INFINITY 65535        /* ÉèΪ˫×Ö½ÚÎÞ·ûºÅÕýÊýµÄ×î´óÖµ65535*/
typedef int Vertex;         /* Óö¥µãϱê±íʾ¶¥µã,ΪÕûÐÍ */
typedef int WeightType;        /* ±ßµÄȨֵÉèΪÕûÐÍ */
typedef char DataType;        /* ¶¥µã´æ´¢µÄÊý¾ÝÀàÐÍÉèΪ×Ö·ûÐÍ */
  
/* ±ßµÄ¶¨Òå */
typedef struct ENode *PtrToENode;
struct ENode{
    Vertex V1, V2;      /* ÓÐÏò±ß<V1, V2> */
    WeightType Weight;  /* ȨÖØ */
};
typedef PtrToENode Edge;
         
/* ͼ½áµãµÄ¶¨Òå */
typedef struct GNode *PtrToGNode;
struct GNode{
    int Nv;  /* ¶¥µãÊý */
    int Ne;  /* ±ßÊý   */
    WeightType G[MaxVertexNum][MaxVertexNum]; /* ÁÚ½Ó¾ØÕó */
    DataType Data[MaxVertexNum];      /* ´æ¶¥µãµÄÊý¾Ý */
    /* ×¢Ò⣺ºÜ¶àÇé¿öÏ£¬¶¥µãÎÞÊý¾Ý£¬´ËʱData[]¿ÉÒÔ²»ÓóöÏÖ */
};
typedef PtrToGNode MGraph; /* ÒÔÁÚ½Ó¾ØÕó´æ´¢µÄͼÀàÐÍ */
bool Visited[MaxVertexNum] = {false};

MGraph CreateGraph( int VertexNum );
void InsertEdge( MGraph Graph, Edge E );
MGraph BuildGraph();
bool IsEdge( MGraph Graph, Vertex V, Vertex W );
void InitVisited();
Vertex BFS ( MGraph Graph, Vertex S, void (*Visit)(Vertex) );
Vertex DFS ( MGraph Graph, Vertex S, void (*Visit)(Vertex) );
Vertex listDFS( MGraph Graph, void (*Visit)(Vertex) );
void DFSListComponents( MGraph Graph, void (*Visit)(Vertex) );
void BFSListComponents( MGraph Graph, void (*Visit)(Vertex) ); 

MGraph CreateGraph( int VertexNum )
{ /* ³õʼ»¯Ò»¸öÓÐVertexNum¸ö¶¥µãµ«Ã»ÓбߵÄͼ */
    Vertex V, W;
    MGraph Graph;
      
    Graph = (MGraph)malloc(sizeof(struct GNode)); /* ½¨Á¢Í¼ */
    Graph->Nv = VertexNum;
    Graph->Ne = 0;
    /* ³õʼ»¯ÁÚ½Ó¾ØÕó */
    /* ×¢Ò⣺ÕâÀïĬÈ϶¥µã±àºÅ´Ó0¿ªÊ¼£¬µ½(Graph->Nv - 1) */
    for (V=0; V<Graph->Nv; V++)
        for (W=0; W<Graph->Nv; W++)  
            Graph->G[V][W] = INFINITY;
              
    return Graph; 
}
         
void InsertEdge( MGraph Graph, Edge E )
{
     /* ²åÈë±ß <V1, V2> */
     Graph->G[E->V1][E->V2] = E->Weight;    
     /* ÈôÊÇÎÞÏòͼ£¬»¹Òª²åÈë±ß<V2, V1> */
     Graph->G[E->V2][E->V1] = E->Weight;
}
  
MGraph BuildGraph()
{
    MGraph Graph;
    Edge E;
    Vertex V;
    int Nv, i;
      
    scanf("%d", &Nv);   /* ¶ÁÈ붥µã¸öÊý */
    Graph = CreateGraph(Nv); /* ³õʼ»¯ÓÐNv¸ö¶¥µãµ«Ã»ÓбߵÄͼ */ 
      
    scanf("%d", &(Graph->Ne));   /* ¶ÁÈë±ßÊý */
    if ( Graph->Ne != 0 ) { /* Èç¹ûÓÐ±ß */ 
        E = (Edge)malloc(sizeof(struct ENode)); /* ½¨Á¢±ß½áµã */ 
        /* ¶ÁÈë±ß£¬¸ñʽΪ"Æðµã ÖÕµã ȨÖØ"£¬²åÈëÁÚ½Ó¾ØÕó */
        for (i=0; i<Graph->Ne; i++) {
            scanf("%d %d %d", &E->V1, &E->V2, &E->Weight); 
            /* ×¢Ò⣺Èç¹ûȨÖز»ÊÇÕûÐÍ£¬WeightµÄ¶ÁÈë¸ñʽҪ¸Ä */
            InsertEdge( Graph, E );
        }
    } 
  
    /* Èç¹û¶¥µãÓÐÊý¾ÝµÄ»°£¬¶ÁÈëÊý¾Ý */
    for (V=0; V<Graph->Nv; V++) 
        scanf(" %c", &(Graph->Data[V]));
  
    return Graph;
}
/* ÁÚ½Ó¾ØÕó´æ´¢µÄͼ - BFS */
  
/* IsEdge(Graph, V, W)¼ì²é<V, W>ÊÇ·ñͼGraphÖеÄÒ»Ìõ±ß£¬¼´WÊÇ·ñVµÄÁڽӵ㡣  */
/* ´Ëº¯Êý¸ù¾ÝͼµÄ²»Í¬ÀàÐÍÒª×ö²»Í¬µÄʵÏÖ£¬¹Ø¼üÈ¡¾öÓÚ¶Ô²»´æÔڵıߵıíʾ·½·¨¡£*/
/* ÀýÈç¶ÔÓÐȨͼ, Èç¹û²»´æÔڵı߱»³õʼ»¯ÎªINFINITY, Ôòº¯ÊýʵÏÖÈçÏÂ:         */
bool IsEdge( MGraph Graph, Vertex V, Vertex W )
{
    return Graph->G[V][W]<INFINITY ? true : false;
}

//³õʼ»¯ Visited[] = false
void InitVisited()
{
    for(int i = 0; i < MaxVertexNum; i++)
        Visited[i] = false;
} 

void Visit(Vertex v)
{
    printf("%d ",v);
}

/* Visited[]Ϊȫ¾Ö±äÁ¿£¬ÒѾ­³õʼ»¯Îªfalse */
Vertex BFS ( MGraph Graph, Vertex S, void (*Visit)(Vertex) )
{   /* ÒÔSΪ³ö·¢µã¶ÔÁÚ½Ó¾ØÕó´æ´¢µÄͼGraph½øÐÐBFSËÑË÷ */
    queue<Vertex> Q;     
    Vertex V, W;
  
    /* ·ÃÎʶ¥µãS£º´Ë´¦¿É¸ù¾Ý¾ßÌå·ÃÎÊÐèÒª¸Äд */
    Visit( S );
    Visited[S] = true; /* ±ê¼ÇSÒÑ·ÃÎÊ */
    Q.push(S); /* SÈë¶ÓÁÐ */
      
    while ( !Q.empty() ) {
        V = Q.front();
        Q.pop();      /* µ¯³öV */
        for( W=0; W < Graph->Nv; W++ ) /* ¶ÔͼÖеÄÿ¸ö¶¥µãW */
            /* ÈôWÊÇVµÄÁڽӵ㲢ÇÒδ·ÃÎʹý */
            if ( !Visited[W] && IsEdge(Graph, V, W) ) {
                /* ·ÃÎʶ¥µãW */
                Visit( W );
                Visited[W] = true; /* ±ê¼ÇWÒÑ·ÃÎÊ */
                Q.push(W); /* WÈë¶ÓÁÐ */
            }
    } /* while½áÊø*/
    //ÒÑÓà BFSListComponents( MGraph Graph, void (*Visit)(Vertex) )½øÐиĽø 
//    printf("\n");
//    
//    //±éÀú Visited[]ÁгöËùÓÐBFSµÄ¶¥µã ÈôÖ»ÐèÒ»¸ö¶¥µã¿ªÊ¼µÄBFS¿ÉºöÂÔ 
//    Vertex i;
//    for(i = 0; i < Graph->Nv; i++) {
//        if(Visited[i] == false)//ÕÒ³öδ±»·ÃÎʹýµÄ½áµã¼Ç¼iÖµ 
//            break;
//    }
//    if(i == Graph->Nv)
//        return 0;
//    else
//        return BFS(Graph,i,Visit);
}

/* ÒÔSΪ³ö·¢µã¶ÔÁÚ½Ó¾ØÕó´æ´¢µÄͼGraph½øÐÐDFSËÑË÷ */
Vertex DFS ( MGraph Graph, Vertex S, void (*Visit)(Vertex) )
{
    Visited[S] = true;
    Visit(S);
    for(Vertex w = 0; w < Graph->Nv; w++) {
        if( IsEdge(Graph, S, w) && Visited[w]==false) {
            DFS(Graph,w,Visit);
        }
    }    
}
//ÁгöDFSµÄËùÓж¥µã ÒÑÓÃDFSListComponents( MGraph Graph, void (*Visit)(Vertex) )½øÐиĽø 
Vertex listDFS( MGraph Graph, void (*Visit)(Vertex) )
{
    Vertex i;
    for(i = 0; i < Graph->Nv; i++) {
        if(Visited[i] == false)//ÕÒ³öδ±»·ÃÎʹýµÄ½áµã¼Ç¼iÖµ 
            break;
    }
    if(i == Graph->Nv)
        return 0;
    DFS(Graph, i, Visit);
    printf("\n");
    
    return listDFS(Graph,Visit);
}
void DFSListComponents( MGraph Graph, void (*Visit)(Vertex) )
{ 
    for(Vertex i = 0; i < Graph->Nv; i++) {
        if(Visited[i] == false) {
            DFS(Graph, i, Visit);
            printf("\n");
        }
    }      
}
void BFSListComponents( MGraph Graph, void (*Visit)(Vertex) )
{ 
    for(Vertex i = 0; i < Graph->Nv; i++) {
        if(Visited[i] == false) {
            BFS(Graph, i, Visit);
            printf("\n");
        }
    }      
}

int main()
{
    MGraph graph;
    graph = BuildGraph();
    InitVisited(); 
    listDFS(graph,&Visit);
    InitVisited(); 
    DFSListComponents(graph,&Visit); 
    InitVisited(); 
//    BFS(graph,0,&Visit);
    BFSListComponents(graph,&Visit); 
    return 0;
} 

 

二.鄰接表

G[N]為指針數組，對應矩陣每行一個鏈表，只存非0元素。

鄰接表的優點
　　方便找任一頂點的所有“鄰接點”
　　節約稀疏圖的空間
　　需要N個頭指針+ 2E個結點（每個結點至少2個域）
　　方便計算任一頂點的“度”？
　　　　對無向圖：是的
　　　　對有向圖：只能計算“出度”；需要構造“逆鄰接表”（存指向自己的邊）來方便計算“入度”

鄰接表的缺點

　　不方便檢查任意一對頂點間是否存在邊

/* 圖的鄰接表表示法 */ 
//build用的 頭插法 尾插法遍歷 出來不同 但無影響 
#include <iostream>
#include <cstdio>
#include <cstdlib> 
#include <queue>
using namespace std;

#define MaxVertexNum 100    /* 最大頂點數設為100 */
typedef int Vertex;         /* 用頂點下標表示頂點,為整型 */
typedef int WeightType;        /* 邊的權值設為整型 */
typedef char DataType;        /* 頂點存儲的數據類型設為字符型 */
  
/* 邊的定義 */
typedef struct ENode *PtrToENode;
struct ENode{
    Vertex V1, V2;      /* 有向邊<V1, V2> */
    WeightType Weight;  /* 權重 */
};
typedef PtrToENode Edge;
  
/* 鄰接點的定義 */
typedef struct AdjVNode *PtrToAdjVNode; 
struct AdjVNode{
    Vertex AdjV;        /* 鄰接點下標 */
    WeightType Weight;  /* 邊權重 */
    PtrToAdjVNode Next;    /* 指向下一個鄰接點的指針 */
};
  
/* 頂點表頭結點的定義 */
typedef struct Vnode{
    PtrToAdjVNode FirstEdge;/* 邊表頭指針 */
    DataType Data;            /* 存頂點的數據 */
    /* 注意：很多情況下，頂點無數據，此時Data可以不用出現 */
} AdjList[MaxVertexNum];    /* AdjList是鄰接表類型 */
  
/* 圖結點的定義 */
typedef struct GNode *PtrToGNode;
struct GNode{  
    int Nv;     /* 頂點數 */
    int Ne;     /* 邊數   */
    AdjList G;  /* 鄰接表 */
};
typedef PtrToGNode LGraph; /* 以鄰接表方式存儲的圖類型 */
bool Visited[MaxVertexNum] = {false}; 

LGraph CreateGraph( int VertexNum );
void InsertEdge( LGraph Graph, Edge E );
LGraph BuildGraph();
void Visit( Vertex V );
void InitVisited();
void DFS( LGraph Graph, Vertex V, void (*Visit)(Vertex) );
Vertex listDFS( LGraph Graph, void (*Visit)(Vertex) );
int BFS( LGraph Graph, Vertex V, void (*Visit)(Vertex) );
void DFSListComponents( LGraph Graph, void (*Visit)(Vertex) );
void BFSListComponents( LGraph Graph, void (*Visit)(Vertex) );
 
LGraph CreateGraph( int VertexNum )
{ /* 初始化一個有VertexNum個頂點但沒有邊的圖 */
    Vertex V;
    LGraph Graph;
      
    Graph = (LGraph)malloc( sizeof(struct GNode) ); /* 建立圖 */
    Graph->Nv = VertexNum;
    Graph->Ne = 0;
    /* 初始化鄰接表頭指針 */
    /* 注意：這里默認頂點編號從0開始，到(Graph->Nv - 1) */
       for (V=0; V<Graph->Nv; V++)
        Graph->G[V].FirstEdge = NULL;
              
    return Graph; 
}
         
void InsertEdge( LGraph Graph, Edge E )
{
    PtrToAdjVNode NewNode;
      
    /* 插入邊 <V1, V2> */
    /* 為V2建立新的鄰接點 */
    NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
    NewNode->AdjV = E->V2;
    NewNode->Weight = E->Weight;
    /* 將V2插入V1的表頭 */
    NewNode->Next = Graph->G[E->V1].FirstEdge;
    Graph->G[E->V1].FirstEdge = NewNode;
          
    /* 若是無向圖，還要插入邊 <V2, V1> */
    /* 為V1建立新的鄰接點 */
    NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
    NewNode->AdjV = E->V1;
    NewNode->Weight = E->Weight;
    /* 將V1插入V2的表頭 */
    NewNode->Next = Graph->G[E->V2].FirstEdge;
    Graph->G[E->V2].FirstEdge = NewNode;
}
  
LGraph BuildGraph()
{
    LGraph Graph;
    Edge E;
    Vertex V;
    int Nv, i;
      
    scanf("%d", &Nv);   /* 讀入頂點個數 */
    Graph = CreateGraph(Nv); /* 初始化有Nv個頂點但沒有邊的圖 */ 
      
    scanf("%d", &(Graph->Ne));   /* 讀入邊數 */
    if ( Graph->Ne != 0 ) { /* 如果有邊 */ 
        E = (Edge)malloc( sizeof(struct ENode) ); /* 建立邊結點 */ 
        /* 讀入邊，格式為"起點 終點 權重"，插入鄰接矩陣 */
        for (i=0; i<Graph->Ne; i++) {
            scanf("%d %d %d", &E->V1, &E->V2, &E->Weight); 
            /* 注意：如果權重不是整型，Weight的讀入格式要改 */
            InsertEdge( Graph, E );
        }
    } 
  
    /* 如果頂點有數據的話，讀入數據 */
    for (V=0; V<Graph->Nv; V++) 
        scanf(" %c", &(Graph->G[V].Data));
  
    return Graph;
}

void Visit( Vertex V )
{
    printf("%d ", V);
}

//初始化 Visited[] = false
void InitVisited()
{
    for(int i = 0; i < MaxVertexNum; i++)
        Visited[i] = false;
}  

/* Visited[]為全局變量，已經初始化為false */
void DFS( LGraph Graph, Vertex V, void (*Visit)(Vertex) )
{   /* 以V為出發點對鄰接表存儲的圖Graph進行DFS搜索 */
    PtrToAdjVNode W;
      
    Visit( V ); /* 訪問第V個頂點 */
    Visited[V] = true; /* 標記V已訪問 */
  
    for( W=Graph->G[V].FirstEdge; W; W=W->Next ) /* 對V的每個鄰接點W->AdjV */
        if ( !Visited[W->AdjV] )    /* 若W->AdjV未被訪問 */
            DFS( Graph, W->AdjV, Visit );    /* 則遞歸訪問之 */
}
//已用InitVisited();進行改進 
Vertex listDFS( LGraph Graph, void (*Visit)(Vertex) )
{
    Vertex i;
    for(i = 0; i < Graph->Nv; i++) {
        if(Visited[i] == false)//找出未被訪問過的結點記錄i值 
            break;
    }
    if(i == Graph->Nv)
        return 0;
    DFS(Graph, i, Visit);
    printf("\n");
    return listDFS(Graph,Visit);
} 
//圖不連通時 列出各連通分量 
void DFSListComponents( LGraph Graph, void (*Visit)(Vertex) )
{ 
    for(Vertex i = 0; i < Graph->Nv; i++) {
        if(Visited[i] == false) {
            DFS(Graph, i, Visit);
            printf("\n");
        }
    }      
}
int BFS( LGraph Graph, Vertex V, void (*Visit)(Vertex) )
{
    queue<Vertex> Q;     
    Vertex W;
    
    Visit( V ); /* 訪問第V個頂點 */
    Visited[V] = true; /* 標記V已訪問 */
    Q.push(V);
    
    while( !Q.empty() ) {
        W = Q.front();
        Q.pop();
        for(PtrToAdjVNode tempV = Graph->G[W].FirstEdge; tempV; tempV=tempV->Next ) /* 對W的每個鄰接點tempV->AdjV */
            if( !Visited[tempV->AdjV]) {
                Visited[tempV->AdjV] = true;
                Visit(tempV->AdjV);
                Q.push(tempV->AdjV);
            }
    }
    //已用 BFSListComponents進行改進 
//    printf("\n");
//    
//    //遍歷 Visited[]列出所有BFS的頂點 若只需一個頂點開始的BFS可忽略 
//    Vertex i;
//    for(i = 0; i < Graph->Nv; i++) {
//        if(Visited[i] == false)//找出未被訪問過的結點記錄i值 
//            break;
//    }
//    if(i == Graph->Nv)
//        return 0;
//    else
//        return BFS(Graph,i,Visit);
    return 0;
}
//圖不連通時 列出各連通分量 
void BFSListComponents( LGraph Graph, void (*Visit)(Vertex) )
{ 
    for(Vertex i = 0; i < Graph->Nv; i++) {
        if(Visited[i] == false) {
            BFS(Graph, i, Visit);
            printf("\n");
        }
    }      
}


int main()
{
    LGraph graph;
    graph = BuildGraph();
    InitVisited();
    listDFS(graph,&Visit);
    InitVisited();
    DFSListComponents(graph,&Visit);
    InitVisited();
//    BFS(graph, 0, &Visit);
    BFSListComponents(graph,&Visit);
    return 0;
}

 

三.BFS廣度優先搜索(Breadth First Search, BFS)

運用隊列，將頂點V的每個鄰接點進隊。(類似於樹的層先遍歷)

若有N個頂點、E條邊，時間復雜度是

　　用鄰接表存儲圖，有O(N+E)
　　用鄰接矩陣存儲圖，有O(N^2)

 

四.DFS深度優先搜索索(Depth First Search, DFS)

用遞歸(類似於樹的先序遍歷)。

ListComponents 圖不連通時，列出各連通分量。

若有N個頂點、E條邊，時間復雜度是

　　用鄰接表存儲圖，有O(N+E)
　　用鄰接矩陣存儲圖，有O(N^2)

 

五.最短路徑

　　兩個不同頂點之間的所有路徑中，邊的權值之和最小的那一條路徑

　　　　第一個頂點為源點(Source)

　　　　最后一個頂點為終點(Destination)

 

單源最短路徑問題：從某固定源點出發，求其到所有其他頂點的最短路徑

無權圖(無論是否有向)：按照路徑長度遞增（非遞減）的順序找出到各個頂點的最短路

類似於BFS，運用隊列

dist[W] = S到W最短距離

dist[S] = 0;

path[W] = S到W路上經過的頂點

時間復雜度T = O(V + E)

/* dist[]和path[]全部初始化為-1 */
void Unweighted ( LGraph Graph, int dist[], int path[], Vertex S )
{
    queue<Vertex> Q;
    Vertex V;
    PtrToAdjVNode W;
     
    dist[S] = 0; /* 初始化源點 */
    Q.push(S);
 
    while( !Q.empty() ){
        V = Q.front();
        Q.pop();
        for ( W = Graph->G[V].FirstEdge; W; W = W->Next ) /* 對V的每個鄰接點W->AdjV */
            if ( dist[W->AdjV] == -1 ) { /* 若W->AdjV未被訪問過 */
                dist[W->AdjV] = dist[V] + 1; /* W->AdjV到S的距離更新 */
                path[W->AdjV] = V; /* 將V記錄在S到W->AdjV的路徑上 */
                Q.push(W->AdjV);
            }
    } /* while結束*/
}

 

有權圖(無論是否有向):按照遞增的順序找出到各個頂點的最短路

Dijkstra 算法

　　令S={源點s + 已經確定了最短路徑的頂點vi}

　　對任一未收錄的頂點v，定義dist[v]為s到v的最短路徑長度，但該路徑僅經過S中的頂點。即路徑{s-->(vi∈S)-->v}的最小長度

　　路徑是按照遞增（非遞減）的順序生成的，則

　　　　 真正的最短路必須只經過S中的頂點(!!!) 因為是遞增的順序生成 如果頂點w不再路徑集合上 然而是最短，應該早就收錄了(意會。。。)

　　　　 每次從未收錄的頂點中選一個dist最小的收錄（貪心）

　　　　 增加一個v進入S，可能影響另外一個w的dist值！(如果收錄v使得s到w的路徑變短，則s到w的路徑一定經過v，並且v到w有一條邊)

　　　　　　dist[w] = min{dist[w], dist[v] + <v,w>的權重}

　白話算法：

　每次找到dist最小的值，即第一次找到S和第二個頂點dist最小的那個，　　　　          比較更新該頂點未訪問過的鄰接點的dist　　　　       　　　　　　　　　　              然后一直找dist最小的

 

　　

　　不能有負值圈

 

圖只更新dist[]中的值 不改變鄰接矩陣的值！

/* 鄰接矩陣存儲 - 有權圖的單源最短路算法 */
Vertex FindMinDist( MGraph Graph, int dist[], int collected[] )
{ /* 返回未被收錄頂點中dist最小者 */
    Vertex MinV, V;
    int MinDist = INFINITY;
 
    for (V=0; V<Graph->Nv; V++) {
        if ( collected[V]==false && dist[V] < MinDist) {
            /* 若V未被收錄，且dist[V]更小 */
            MinDist = dist[V]; /* 更新最小距離 */
            MinV = V; /* 更新對應頂點 */
        }
    }
    if (MinDist < INFINITY) /* 若找到最小dist */
        return MinV; /* 返回對應的頂點下標 */
    else return ERROR;  /* 若這樣的頂點不存在，返回錯誤標記 */
}
 
bool Dijkstra( MGraph Graph, int dist[], int path[], Vertex S )
{
    int collected[MaxVertexNum];
    Vertex V, W;
 
    /* 初始化：此處默認鄰接矩陣中不存在的邊用INFINITY表示 */
    for ( V=0; V < Graph->Nv; V++ ) {
        dist[V] = Graph->G[S][V];
        path[V] = -1;
        collected[V] = false;
    }
    /* 先將起點收入集合 */
    dist[S] = 0;
    collected[S] = true;
 
    while (1) {
        /* V = 未被收錄頂點中dist最小者 */
        V = FindMinDist( Graph, dist, collected );
        if ( V==ERROR ) /* 若這樣的V不存在 */
            break;      /* 算法結束 */
        collected[V] = true;  /* 收錄V */
        for( W = 0; W < Graph->Nv; W++ ) /* 對圖中的每個頂點W */
            /* 若W是V的鄰接點並且未被收錄 */
            if ( collected[W]==false && Graph->G[V][W]<INFINITY ) {
                if ( Graph->G[V][W]<0 ) /* 若有負邊 */
                    return false; /* 不能正確解決，返回錯誤標記 */
                /* 若收錄V使得dist[W]變小 */
                if ( dist[V]+Graph->G[V][W] < dist[W] ) {
                    dist[W] = dist[V] + Graph->G[V][W]; /* 更新dist[W] */
                    path[W] = V; /* 更新S到W的路徑 */
                }
            }
    } /* while結束*/
    return true; /* 算法執行完畢，返回正確標記 */
}

關於找最小dist

　　①直接掃描所有未收錄頂點-O(V)

　　　　T=O(V^2+E)   --->對於稠密圖效果好

　　②將dist存在最小堆中-O(logV)

　　　　更新dist(W)的值-O(logV)

　　　　T = O(VlogV+ElogV) = O(ElogV)    --->對於稠稀疏圖效果好

 

多源最短路徑問題：求任意兩頂點間的最短路徑

方法一：直接將單源最短路算法調用V遍

　　　　T = O(V^3 + E*V)   --->對於稀疏圖效果好

方法二：Floyd算法　　--->對於稠密圖效果好

　　　　T = O(V^3)

Floyd 算法

　　Dk[i][j] = 路徑{ i -> { l ≤ k } -> j }的最小長度

　　D0, D1, …, D|V|-1[i][j]即給出了i到j的真正最短距離

　　最初的D-1是鄰接矩陣

　　當Dk-1已經完成，遞推到Dk時：

　　　　或者k ∉最短路徑{ i -> { l ≤ k } -> j }，則Dk = Dk-1

　　　　或者k ∈最短路徑{ i -> { l ≤ k } -> j }，則該路徑必定由兩段最短路徑組成： Dk[i][j]=Dk-1[i][k]+Dk-1[k][j]

/* 鄰接矩陣存儲 - 多源最短路算法 */
 
bool Floyd( MGraph Graph, WeightType D[][MaxVertexNum], Vertex path[][MaxVertexNum] )
{
    Vertex i, j, k;
 
    /* 初始化 */
    for ( i=0; i<Graph->Nv; i++ )
        for( j=0; j<Graph->Nv; j++ ) {
            D[i][j] = Graph->G[i][j];
            path[i][j] = -1;
        }
 
    for( k=0; k<Graph->Nv; k++ )
        for( i=0; i<Graph->Nv; i++ )
            for( j=0; j<Graph->Nv; j++ )
                if( D[i][k] + D[k][j] < D[i][j] ) {
                    D[i][j] = D[i][k] + D[k][j];
                    if ( i==j && D[i][j]<0 ) /* 若發現負值圈 */
                        return false; /* 不能正確解決，返回錯誤標記 */
                    path[i][j] = k;
                }
    return true; /* 算法執行完畢，返回正確標記 */
}