2. 程式人生 > >C++】判斷一個圖是否有環 無向圖 有向圖（轉載）

C++】判斷一個圖是否有環 無向圖 有向圖（轉載）

阿新 • • 發佈：2019-02-07

沒有找到原文出處，請參考一下連結：

一、無向圖：

方法1：

  • 如果存在迴路，則必存在一個子圖，是一個環路。環路中所有頂點的度>=2。  
  • n演算法：  

     第一步：刪除所有度<=1的頂點及相關的邊，並將另外與這些邊相關的其它頂點的度減一。  

     第二步：將度數變為1的頂點排入佇列，並從該佇列中取出一個頂點重複步驟一。  

     如果最後還有未刪除頂點，則存在環，否則沒有環。  

  • n演算法分析：  

     由於有m條邊，n個頂點。

     i)如果m>=n，則根據圖論知識可直接判斷存在環路。（證明：如果沒有環路，則該圖必然是k棵樹 k>=1。根據樹的性質，邊的數目m = n-k。k>=1，所以：m<n）              

     ii)如果m<n 則按照上面的演算法每刪除一個度為0的頂點操作一次（最多n次），或每刪除一個度為1的頂點（同時刪一條邊）操作一次（最多m次）。這兩種操作的總數不會超過m+n。由於m<n，所以演算法複雜度為O(n)。

  • 注：

     該方法，演算法複雜度不止O(V)，首先初始時刻統計所有頂點的度的時候，複雜度為(V + E)，即使在後來的迴圈中E>=V，這樣演算法的複雜度也只能為O(V + E)。其次，在每次迴圈時，刪除度為1的頂點，那麼就必須將與這個頂點相連的點的度減一，並且執行delete node from list[list[node]]，這裡查詢的複雜度為list[list[node]]的長度，只有這樣才能保證當degree[i]=1時，list[i]裡面只有一個點。這樣最差的複雜度就為O(EV)了。

方法2：

DFS搜尋圖，圖中的邊只可能是樹邊或反向邊，一旦發現反向邊，則表明存在環。該演算法的複雜度為O(V)。

方法3：

PS：此方法於2011-6-12補充

假定：圖頂點個數為M，邊條數為E

遍歷一遍，判斷圖分為幾部分（假定為P部分，即圖有 P 個連通分量） 對於每一個連通分量，如果無環則只能是樹，即：邊數＝結點數－1 只要有一個滿足      邊數   >   結點數－1
原圖就有環
將P個連通分量的不等式相加，就得到： P1:E1=M1-1 P2:E2=M2-1 ... PN:EN>MN-1     所有邊數(E)   >   所有結點數(M) - 連通分量個數(P)
即：  E + P > M  所以只要判斷結果  E  + P > M 就表示原圖有環，否則無環.

例項程式碼如下：

  1. #include<iostream>  
  2. #include<malloc.h>  
  3. using namespace std;  
  4. #define maxNum 100 //定義鄰接舉證的最大定點數  
  5. int visited[maxNum];//通過visited陣列來標記這個頂點是否被訪問過，0表示未被訪問，1表示被訪問  
  6. int DFS_Count;//連通部件個數，用於測試無向圖是否連通，DFS_Count=1表示只有一個連通部件，所以整個無向圖是連通的  
  7. int pre[maxNum];  
  8. int post[maxNum];  
  9. int point;//pre和post的值  
  10. //圖的鄰接矩陣表示結構  
  11. typedef struct  
  12. {  
  13.     char v[maxNum];//圖的頂點資訊  
  14.     int e[maxNum][maxNum];//圖的頂點資訊  
  15.     int vNum;//頂點個數  
  16.     int eNum;//邊的個數  
  17. }graph;  
  18. void createGraph(graph *g);//建立圖g  
  19. void DFS(graph *g);//深度優先遍歷圖g  
  20. void dfs(graph *g,int i);//從頂點i開始深度優先遍歷與其相鄰的點  
  21. void dfs(graph *g,int i)  
  22. {  
  23.     //cout<<"頂點"<<g->v[i]<<"已經被訪問"<<endl;  
  24.     cout<<"頂點"<<i<<"已經被訪問"<<endl;  
  25.     visited[i]=1;//標記頂點i被訪問  
  26.     pre[i]=++point;  
  27.     for(int j=1;j<=g->vNum;j++)  
  28.     {  
  29.         if(g->e[i][j]!=0&&visited[j]==0)  
  30.             dfs(g,j);  
  31.     }  
  32.     post[i]=++point;  
  33. }  
  34. void DFS(graph *g)  
  35. {  
  36.     int i;  
  37.     //初始化visited陣列，表示一開始所有頂點都未被訪問過  
  38.     for(i=1;i<=g->vNum;i++)  
  39.     {  
  40.         visited[i]=0;  
  41.         pre[i]=0;  
  42.         post[i]=0;  
  43.     }  
  44.     //初始化pre和post  
  45.     point=0;  
  46.     //初始化連通部件數為0  
  47.     DFS_Count=0;  
  48.     //深度優先搜尋  
  49.     for(i=1;i<=g->vNum;i++)  
  50.     {  
  51.         if(visited[i]==0)//如果這個頂點為被訪問過，則從i頂點出發進行深度優先遍歷  
  52.         {  
  53.             DFS_Count++;//統計呼叫void dfs(graph *g,int i);的次數  
  54.             dfs(g,i);  
  55.         }  
  56.     }  
  57. }  
  58. void createGraph(graph *g)//建立圖g  
  59. {  
  60.     cout<<"正在建立無向圖..."<<endl;  
  61.     cout<<"請輸入頂點個數vNum:";  
  62.     cin>>g->vNum;  
  63.     cout<<"請輸入邊的個數eNum:";  
  64.     cin>>g->eNum;  
  65.     int i,j;  
  66.     //輸入頂點資訊  
  67.     //cout<<"請輸入頂點資訊："<<endl;  
  68.     //for(i=0;i<g->vNum;i++)  
  69.     //  cin>>g->v[i];  
  70.     //初始畫圖g  
  71.     for(i=1;i<=g->vNum;i++)  
  72.         for(j=1;j<=g->vNum;j++)  
  73.             g->e[i][j]=0;  
  74.     //輸入邊的情況  
  75.     cout<<"請輸入邊的頭和尾"<<endl;  
  76.     for(int k=0;k<g->eNum;k++)  
  77.     {  
  78.         cin>>i>>j;  
  79.         g->e[i][j]=1;  
  80.         g->e[j][i]=1;//無向圖對稱  
  81.     }  
  82. }  
  83. int main()  
  84. {  
  85.     graph *g;  
  86.     g=(graph*)malloc(sizeof(graph));  
  87.     createGraph(g);//建立圖g  
  88.     DFS(g);//深度優先遍歷  
  89.     //連通部件數，用於判斷是否連通圖  
  90.     cout<<"連通部件數量：";  
  91.     cout<<DFS_Count<<endl;  
  92.     if(DFS_Count==1)  
  93.         cout<<"圖g是連通圖"<<endl;  
  94.     else if(DFS_Count>1)  
  95.         cout<<"圖g不是連通圖"<<endl;  
  96.     //各頂點的pre和post值  
  97.     for(int i=1;i<=g->vNum;i++)  
  98.         cout<<"頂點"<<i<<"的pre和post分別為："<<pre[i]<<" "<<post[i]<<endl;  
  99.     //cout<<endl;  
  100.     //判斷無向圖中是否有環  
  101.     if(g->eNum+DFS_Count>g->vNum)  
  102.         cout<<"圖g中存在環"<<endl;  
  103.     else  
  104.         cout<<"圖g中不存在環"<<endl;  
  105.     int k;  
  106.     cin>>k;  
  107.     return 0;  
  108. }  
  109. /* 
  110. 輸入： 
  111. 正在建立無向圖... 
  112. 請輸入頂點個數vNum:10 
  113. 請輸入邊的個數eNum:9 
  114. 請輸入邊的頭和尾 
  115. 1 2 
  116. 1 4 
  117. 2 5 
  118. 2 6 
  119. 4 7 
  120. 5 9 
  121. 6 3 
  122. 7 8 
  123. 9 10 
  124. */  

注意：有向圖不能使用此方法。比如1->2,1-3,2->3,4->5，如果使用上述方法會判定為含有還，但並非如此。

有向圖：

主要有深度優先和拓撲排序2中方法

1、拓撲排序，如果能夠用拓撲排序完成對圖中所有節點的排序的話，就說明這個圖中沒有環，而如果不能完成，則說明有環。

2、可以用Strongly Connected Components來做，我們可以回憶一下強連通子圖的概念，就是說對於一個圖的某個子圖，該子圖中的任意u->v,必有v->u，則這是一個強連通子圖。這個限定正好是環的概念。所以我想，通過尋找圖的強連通子圖的方法應該可以找出一個圖中到底有沒有環、有幾個環。

3、就是用一個改進的DFS

    剛看到這個問題的時候，我想單純用DFS就可以解決問題了。但細想一下，是不能夠的。如果題目給出的是一個無向圖，那麼OK，DFS是可以解決的。但無向圖得不出正確結果的。比如：A->B,A->C->B,我們用DFS來處理這個圖，我們會得出它有環，但其實沒有。

    我們可以對DFS稍加變化，來解決這個問題。解決的方法如下：

    圖中的一個節點，根據其C[N]的值，有三種狀態：

    0，此節點沒有被訪問過

    -1，被訪問過至少1次，其後代節點正在被訪問中

    1，其後代節點都被訪問過。

    按照這樣的假設，當按照DFS進行搜尋時，碰到一個節點時有三種可能：

    1、如果C[V]=0，這是一個新的節點，不做處理

    2、如果C[V]=-1，說明是在訪問該節點的後代的過程中訪問到該節點本身，則圖中有環。

    3、如果C[V]=1，類似於2的推導，沒有環。    在程式中加上一些特殊的處理，即可以找出圖中有幾個環，並記錄每個環的路徑

PS：此程式碼實現於2011-6-13補充

改進DFS演算法程式碼示例（判斷是否是一個有向無環圖）

  1. #include<iostream>  
  2. #include<malloc.h>  
  3. using namespace std;  
  4. #define maxNum 100 //定義鄰接舉證的最大定點數  
  5. int pre[maxNum];  
  6. int post[maxNum];  
  7. int point=0;//pre和post的值  
  8. bool is_DAG=true;//標識位，表示有向無環圖  
  9. /* 
  10. 頂點顏色表 color[u] 
  11. 　　 0 白色，未被訪問過的節點標白色 
  12. 　　 -1 灰色，已經被訪問過一次的節點標灰色 
  13. 　　 1 黑色，當該節點的所有後代都被訪問過標黑色 
  14. 反向邊： 
  15. 　　 如果第一次訪問(u,v)時v為灰色，則(u,v)為反向邊。在對圖的深度優先搜尋中沒有發現 
  16. 　　 反向邊，則該圖沒有迴路 
  17. 程式判斷依據： 
  18.     仍然是按圖的節點深度遍歷，訪問到V時，V若被訪問過，那麼有2種狀態： 
  19.     color[u]=-1，程式跳出，存在環 
  20.     color[u]=1，程式繼續，這不是環 
  21. 時間複雜度：O(n+e) 
  22. */  
  23. int color[maxNum];//頂點顏色表 color[u]  
  24. //圖的鄰接矩陣表示結構  
  25. typedef struct  
  26. {  
  27.     char v[maxNum];//圖的頂點資訊  
  28.     int e[maxNum][maxNum];//圖的頂點資訊  
  29.     int vNum;//頂點個數  
  30.     int eNum;//邊的個數  
  31. }graph;  
  32. void createGraph(graph *g);//建立圖g  
  33. void DFS(graph *g);//深度優先遍歷圖g  
  34. void dfs(graph *g,int i);//從頂點i開始深度優先遍歷與其相鄰的點  
  35. void dfs(graph *g,int i)  
  36. {  
  37.     //cout<<"頂點"<<g->v[i]<<"已經被訪問"<<endl;  
  38.     cout<<"頂點"<<i<<"已經被訪問"<<endl;  
  39.     color[i]=-1;  
  40.     pre[i]=++point;  
  41.     for(int j=1;j<=g->vNum;j++)  
  42.     {  
  43.         if(g->e[i][j]!=0)  
  44.         {     
  45.             if(color[j]==-1)//探索到回邊,存在環  
  46.             {  
  47.                 is_DAG=false;//不是有向無環圖  
  48.             }  
  49.             else if(color[j]==0)  
  50.                 dfs(g,j);  
  51.         }  
  52.     }  
  53.     post[i]=++point;  
  54.     color[i]=1;//表示i的後裔節點都被訪問過  
  55. }  
  56. void DFS(graph *g)  
  57. {  
  58.     int i;  
  59.     //初始化color陣列，表示一開始所有頂點都未被訪問過，//初始化pre和post  
  60.     for(i=1;i<=g->vNum;i++)  
  61.     {  
  62.         color[i]=0;  
  63.         pre[i]=0;  
  64.         post[i]=0;  
  65.     }  
  66.     //深度優先搜尋  
  67.     for(i=1;i<=g->vNum;i++)  
  68.     {  
  69.         if(color[i]==0)//如果這個頂點為被訪問過，則從i頂點出發進行深度優先遍歷  
  70.         {  
  71.             dfs(g,i);  
  72.         }  
  73.     }  
  74. }  
  75. void createGraph(graph *g)//建立圖g  
  76. {  
  77.     cout<<"正在建立無向圖..."<<endl;  
  78.     cout<<"請輸入頂點個數vNum:";  
  79.     cin>>g->vNum;  
  80.     cout<<"請輸入邊的個數eNum:";  
  81.     cin>>g->eNum;  
  82.     int i,j;  
  83.     //初始畫圖g  
  84.     for(i=1;i<=g->vNum;i++)  
  85.         for(j=1;j<=g->vNum;j++)  
  86.             g->e[i][j]=0;  
  87.     //輸入邊的情況  
  88.     cout<<"請輸入邊的頭和尾"<<endl;  
  89.     for(int k=1;k<=g->eNum;k++)  
  90.     {  
  91.         cin>>i>>j;  
  92.         g->e[i][j]=1;  
  93.     }  
  94. }  
  95. int main()  
  96. {  
  97.     graph *g;  
  98.     g=(graph*)malloc(sizeof(graph));  
  99.     createGraph(g);//建立圖g  
  100.     DFS(g);//深度優先遍歷  
  101.     //各頂點的pre和post值  
  102.     for(int i=1;i<=g->vNum;i++)  
  103.         cout<<"頂點"<<i<<"的pre和post分別為："<<pre[i]<<" "<<post[i]<<endl;  
  104.     //判斷是否是有向無環圖  
  105.     if(is_DAG)  
  106.         cout<<"圖g是有向無環圖，沒有環"<<endl;  
  107.     else  
  108.         cout<<"圖g不是有向無環圖，存在環"<<endl;  
  109.     int k;  
  110.     cin>>k;  
  111.     return 0;  
  112. }  
  113. /* 
  114. 輸入1： 
  115. 正在建立無向圖... 
  116. 請輸入頂點個數vNum:3 
  117. 請輸入邊的個數eNum:3 
  118. 請輸入邊的頭和尾 
  119. 1 2 
  120. 1 3 
  121. 3 2 
  122. 輸入2： 
  123. 正在建立無向圖... 
  124. 請輸入頂點個數vNum:4 
  125. 請輸入邊的個數eNum:4 
  126. 請輸入邊的頭和尾 
  127. 1 2 
  128. 2 3 
  129. 3 4 
  130. 4 2 
  131. */ 

相關推薦

C++】判斷一個圖是否有環 無向圖 有向圖（轉載）

沒有找到原文出處，請參考一下連結： 一、無向圖： 方法1： 如果存在迴路，則必存在一個子圖，是一個環路。環路中所有頂點的度>=2。   n演算法：        第一步：刪除所有度<=1的頂點及相關的邊，並將另外與這些邊相關的其它頂點的度減一。     

看到一個牛人的群聊天記錄，超贊！（轉載）

top 不出 說明 話題 悲劇 最好的 至少 防止 自己 下面是聊天記錄原文（http://bbs.csdn.net/topics/390114474來自csdn-bbs）： “ 2012/2/2 15:13:23 有一個原則 2012/2/2 15:13:

matlab和c++混合程式設計---matlab和vs的環境配置問題及方法和步驟（轉載）

matlab和c++混合程式設計---方法和步驟 matlab和c++混合程式設計---matlab和vs的環境配置問題 摘要：Matlab具有很強的數值計算和分析等能力,而C/C++是目前最為流行的高階程式設計語言,兩者互補結合的混合程式設計在科學研究和工程實踐中具有非常重要的意義。從Matlab呼叫C

C#版--判斷一個月有多少天

用switch語句實現，與C語言不同的是，default後必須增加break語句 using System; using System.Collections.Generic; using System.Linq; using System.Text; namespac

【C語言】判斷一個字串是否為迴文字串。

判斷一個字串是否為迴文字串。 #include <stdio.h> int main(void) { char a[100]; int i = 0, j = 0; printf("Plea

【C++】判斷元素是否在vector中，對vector去重，兩個vector求交集、並集

bool iostream space col 求交集 uniq AI void print #include <iostream> #include <vector> #include <algorithm> //sort函數、交並補

【python】判斷一個字符串是否是數字

val imp erro not 判斷 數字 try false urn def is_number(s): try: float(s) return True except ValueError: pass try: impo

2018.10.30 NOIP模擬 有環無向圖（dijkstra+巧妙建圖）

傳送門 建圖巧妙啊。 對於每個點的出邊，我們將它們排序之後依次連邊。 這樣可以把 O (

c語言判斷一個年份是否是閏年

思路是將年份分別除以4,100,400的餘數分別存在four，hundred，fourhundred變數中然後只有兩種情況是閏年其他不是 #include <stdio.h> void main() { int four , hundred , fourhundred , year;

【Learn C】 判斷閏年

#include <stdio.h> int main() { int year; scanf("%d", &year); if (year % 4 == 0) { if (year % 100 != 0) {

【C#】判斷字串中是否包含指定字串,contains與indexof方法效率問題

1 class Program 2 { 3 private const int N = 10000000; 4 private static Stopwatch watch = new Stopwatch(); 5 static v

【演算法】判斷一個字串的所有字元是否全部不同 java程式碼實現

package com.billkang.algorithm; import java.util.HashSet; import java.util.Set; /** * * @author K

C語言判斷一個字串是否是另一個字串的子串

int f(char*s1,char*s2) {  char *p,*q;  for(;*s1!='\0';s1++) {   if (*s2==*s1) {/*判斷字串中是否有和要判斷的字串首字元相同的字元*/     flag=1;    p=s1; /*s1 p為第一

C++如何判斷一個string字串，是否是數字

方法一：判斷字元的ASCII範圍（數字的範圍為48~57） #include <iostream> using namespace std; bool AllisNum(string str); int main( void ) {

【C++】判斷順序棧出棧順序的合法性

//判斷順序棧出棧順序的合法性思想： //給定一個入棧的字串pushstr，再給定一個出棧的字串popstr，根據棧的特性，判斷該出棧順序是否合法 //1.先驗證兩個字串的長度是否相等，不等，則肯定不合法；相等，再進行步驟2. //2.（1）判斷pushstr與popstr

C++中判斷一個檔案是否存在的方法

最進在寫的一個系統需要儲存結果資料，但是儲存結果資料的時候，如果那個資料已經存在，就會無法儲存，所以就需要先判斷是否存在該資料，判斷方法如下： #include<iostream> #include<fstream> using namespace

C語言,判斷一個5位數是不是迴文數。即12321是迴文數，個位與萬位相同，十位與千位相同。

<span style="font-size:18px;color:#330033;">int a = 0; printf("輸入一個五位數:"); scanf("%d",

【C++】實現一個簡潔版的class String

//實現一個簡潔版的class String #include <iostream> #include <string.h> using namespace std; clas

【C++】實現一個複數類（complex）(帶有預設引數的建構函式 )

/*實現一個複數類（complex） class complex { private: double _real; double _image; }; */ #include <iostream

【C/C++】判斷一個數是不是閏年

生活中，我們都知道如何判斷某一年是不是閏年 我們都知道，能被4整除並且不能被100整除的是閏年 能被400整除的也是閏年 根據演算法，我們寫出下面程式 #define _CRT_SECURE_N