判断图里有环

最新推荐文章于 2021-08-30 00:04:49 发布
转载 最新推荐文章于 2021-08-30 00:04:49 发布 · 1.1k 阅读 · 2
文章标签：

#class #system #算法 #list #components #测试

无向图：

法1：

  • 如果存在回路，则必存在一个子图，是一个环路。环路中所有顶点的度>=2。   
  • n算法：   
  •      第一步：删除所有度<=1的顶点及相关的边，并将另外与这些边相关的其它顶点的度减一。   
  •      第二步：将度数变为1的顶点排入队列，并从该队列中取出一个顶点重复步骤一。   
  •      如果最后还有未删除顶点，则存在环，否则没有环。   
  • n算法分析：   
  •      由于有m条边，n个顶点。如果m>=n，则根据图论知识可直接判断存在环路。   
  •     （证明：如果没有环路，则该图必然是k棵树 k>=1。根据树的性质，边的数目m = n-k。k>=1，所以：m<n）   
  •      如果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)。

     

    有向图：

    主要有深度优先和拓扑排序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的推导，没有环。    在程序中加上一些特殊的处理，即可以找出图中有几个环，并记录每个环的路径

     

     

    判断有向图是否有环有三种方法：拓扑排序、深度遍历+回溯、深度遍历 + 判断后退边

    这里使用 拓扑排序 和 深度遍历 + 回溯判断是不是环。使用 深度遍历 + 判断后退边找出环个数 以及环中元素

    1、拓扑排序

    思想：找入度为0的顶点，输出顶点，删除出边。循环到无顶点输出。

    若：输出所有顶点，则课拓扑排序，无环；反之，则不能拓扑排序，有环

    使用：可以使用拓扑排序为有向无环图每一个结点进行编号，拓扑排序输出的顺序可以为编号顺序

    源代码：

    [cpp] view plain copy print ?
    1. #include <iostream>   
    2. using namespace std;  
    3. const int MAX_Vertex_Num = 20;  
    4. template<class VexType,class ArcType>  
    5. class MGraph  
    6. {  
    7. public:  
    8.     void CreateGraph();//创建图   
    9.     int LocateVex(VexType v);//返回顶点v所在顶点向量中的位置（下标）   
    10.     void CheckCircle();  
    11. private:  
    12.     VexType vexs[MAX_Vertex_Num];//顶点向量   
    13.     ArcType arcs[MAX_Vertex_Num][MAX_Vertex_Num]; //这里把邻接矩阵类型用模板表示，主要是为了处理有权值的情况，比如：权值可以为小数（代价），也可以为整数   
    14.     int vexnum;//顶点数   
    15.     int arcnum;//边数   
    16. private:  
    17.     bool TopSort();  
    18. };  
    19.   
    20. template<class VexType,class ArcType>  
    21. void MGraph<VexType,ArcType>::CreateGraph()  
    22. {  
    23.     VexType first;  
    24.     VexType Secend;  
    25.     cout<<"请输入顶点数:";  
    26.     cin>>vexnum;  
    27.     cout<<"请输入边数:";  
    28.     cin>>arcnum;  
    29.     cout<<"请输入各个顶点值：";  
    30.     for (int i=0;i<vexnum;i++)  
    31.     {  
    32.         cin>>vexs[i];  
    33.     }  
    34.     //初始化邻接矩阵   
    35.     for (int i=0;i<arcnum;i++)  
    36.     {  
    37.         for (int j=0;j<arcnum;j++)  
    38.         {  
    39.             arcs[i][j]=0;  
    40.         }  
    41.     }  
    42.     cout<<"请输入边的信息:"<<endl;  
    43.     for (int i=0;i<arcnum;i++)  
    44.     {  
    45.         cin>>first>>Secend;  
    46.         //如果边有权值的话，则还应该输入权值   
    47.         int x = LocateVex(first);  
    48.         int y = LocateVex(Secend);  
    49.         arcs[x][y]=1;//如果是有权的话，这里应该是arc[x][y]=权值   
    50.     }  
    51. }   
    52. /* 
    53. 参数：v：表示顶点向量中一个值 
    54. 函数返回值：函数返回v在顶点向量中的下标 
    55. */  
    56. template<class VexType,class ArcType>  
    57. int MGraph<VexType,ArcType>::LocateVex(VexType v)  
    58. {  
    59.     for (int i=0;i<vexnum;i++)  
    60.     {  
    61.         if (vexs[i]==v)  
    62.         {  
    63.             return i;  
    64.         }  
    65.     }  
    66.     return -1;  
    67. }  
    68. /* 
    69. 有向图可以拓扑排序的条件是：图中没有环。 
    70. 具体方法： 
    71. ⑴ 从图中选择一个入度为0的点加入拓扑序列。 
    72. ⑵ 从图中删除该结点以及它的所有出边（即与之相邻点入度减1）。 
    73.  
    74. */  
    75. template<class VexType,class ArcType>  
    76. bool MGraph<VexType,ArcType>::TopSort()  
    77. {  
    78.     int count = 0;//拓扑排序输出顶点的个数   
    79.     int top = -1;  
    80.     int stack[MAX_Vertex_Num];  
    81.     int indegree[MAX_Vertex_Num]={0};  
    82.     //求各个顶点的入度--邻接矩阵要查询该元素的列（记录入度情况）--   
    83.     //如果是邻接表，就是麻烦在这里，查询结点入度很不方便   
    84.     for (int i=0;i<vexnum;i++)  
    85.     {  
    86.         int num=0;  
    87.         for (int j=0;j<vexnum;j++)  
    88.         {  
    89.             if (arcs[j][i]!=0)  
    90.             {  
    91.                 num++;  
    92.             }  
    93.         }  
    94.         indegree[i]=num;  
    95.     }  
    96.     //把入度为0的顶点入栈   
    97.     for (int i=0;i<vexnum;i++)  
    98.     {  
    99.         if (!indegree[i])  
    100.         {  
    101.             stack[++top]=i;//顶点的下标   
    102.         }  
    103.     }  
    104.     //处理入度为0的结点：把入度为0的结点出栈，删除与之有关的边   
    105.     while (top>-1)  
    106.     {  
    107.         int x = stack[top--];  
    108.         cout<<vexs[x];  
    109.         count++;  
    110.         //把与下标为x的顶点有关的边都去掉（出边）,并改变对应结点的入度   
    111.         for (int i=0;i<vexnum;i++)  
    112.         {  
    113.             if (arcs[x][i]!=0)  
    114.             {  
    115.                 arcs[x][i]=0;//删除到下标为i的顶点的边，这时此顶点的入度减一   
    116.                 indegree[i]--;  
    117.                 if (!indegree[i])//顶点的入度为0，则入栈   
    118.                 {  
    119.                     stack[++top]=i;  
    120.                 }  
    121.             }  
    122.         }  
    123.     }  
    124.     cout<<endl;  
    125.     if (count == vexnum) //能拓扑排序   
    126.     {  
    127.         return true;  
    128.     }  
    129.     return false;  
    130. }  
    131. /* 
    132. 检查图中是不是有环 
    133. 思想： 
    134. 能进行拓扑排序，则无环，反之有环 
    135. */  
    136. template<class VexType,class ArcType>  
    137. void MGraph<VexType,ArcType>::CheckCircle()  
    138. {  
    139.     if (TopSort())  
    140.     {  
    141.         cout<<"无环！"<<endl;  
    142.     }  
    143.     else  
    144.     {  
    145.         cout<<"有环！"<<endl;  
    146.     }  
    147. }  
    148.   
    149. int main()  
    150. {  
    151.     MGraph<char,int> G;  
    152.     G.CreateGraph();  
    153.     G.CheckCircle();  
    154.     system("pause");  
    155.     return 1;  
    156. }  
    #include <iostream>
using namespace std;
const int MAX_Vertex_Num = 20;
template<class VexType,class ArcType>
class MGraph
{
public:
	void CreateGraph();//创建图
	int LocateVex(VexType v);//返回顶点v所在顶点向量中的位置（下标）
	void CheckCircle();
private:
	VexType vexs[MAX_Vertex_Num];//顶点向量
	ArcType arcs[MAX_Vertex_Num][MAX_Vertex_Num]; //这里把邻接矩阵类型用模板表示，主要是为了处理有权值的情况，比如：权值可以为小数（代价），也可以为整数
	int vexnum;//顶点数
	int arcnum;//边数
private:
	bool TopSort();
};

template<class VexType,class ArcType>
void MGraph<VexType,ArcType>::CreateGraph()
{
	VexType first;
	VexType Secend;
	cout<<"请输入顶点数:";
	cin>>vexnum;
	cout<<"请输入边数:";
	cin>>arcnum;
	cout<<"请输入各个顶点值：";
	for (int i=0;i<vexnum;i++)
	{
		cin>>vexs[i];
	}
	//初始化邻接矩阵
	for (int i=0;i<arcnum;i++)
	{
		for (int j=0;j<arcnum;j++)
		{
			arcs[i][j]=0;
		}
	}
	cout<<"请输入边的信息:"<<endl;
	for (int i=0;i<arcnum;i++)
	{
		cin>>first>>Secend;
		//如果边有权值的话，则还应该输入权值
		int x = LocateVex(first);
		int y = LocateVex(Secend);
		arcs[x][y]=1;//如果是有权的话，这里应该是arc[x][y]=权值
	}
} 
/*
参数：v：表示顶点向量中一个值
函数返回值：函数返回v在顶点向量中的下标
*/
template<class VexType,class ArcType>
int MGraph<VexType,ArcType>::LocateVex(VexType v)
{
	for (int i=0;i<vexnum;i++)
	{
		if (vexs[i]==v)
		{
			return i;
		}
	}
	return -1;
}
/*
有向图可以拓扑排序的条件是：图中没有环。
具体方法：
⑴ 从图中选择一个入度为0的点加入拓扑序列。
⑵ 从图中删除该结点以及它的所有出边（即与之相邻点入度减1）。

*/
template<class VexType,class ArcType>
bool MGraph<VexType,ArcType>::TopSort()
{
	int count = 0;//拓扑排序输出顶点的个数
	int top = -1;
	int stack[MAX_Vertex_Num];
	int indegree[MAX_Vertex_Num]={0};
	//求各个顶点的入度--邻接矩阵要查询该元素的列（记录入度情况）--
	//如果是邻接表，就是麻烦在这里，查询结点入度很不方便
	for (int i=0;i<vexnum;i++)
	{
		int num=0;
		for (int j=0;j<vexnum;j++)
		{
			if (arcs[j][i]!=0)
			{
				num++;
			}
		}
		indegree[i]=num;
	}
	//把入度为0的顶点入栈
	for (int i=0;i<vexnum;i++)
	{
		if (!indegree[i])
		{
			stack[++top]=i;//顶点的下标
		}
	}
	//处理入度为0的结点：把入度为0的结点出栈，删除与之有关的边
	while (top>-1)
	{
		int x = stack[top--];
		cout<<vexs[x];
		count++;
		//把与下标为x的顶点有关的边都去掉（出边）,并改变对应结点的入度
		for (int i=0;i<vexnum;i++)
		{
			if (arcs[x][i]!=0)
			{
				arcs[x][i]=0;//删除到下标为i的顶点的边，这时此顶点的入度减一
				indegree[i]--;
				if (!indegree[i])//顶点的入度为0，则入栈
				{
					stack[++top]=i;
				}
			}
		}
	}
	cout<<endl;
	if (count == vexnum) //能拓扑排序
	{
		return true;
	}
	return false;
}
/*
检查图中是不是有环
思想：
能进行拓扑排序，则无环，反之有环
*/
template<class VexType,class ArcType>
void MGraph<VexType,ArcType>::CheckCircle()
{
	if (TopSort())
	{
		cout<<"无环！"<<endl;
	}
	else
	{
		cout<<"有环！"<<endl;
	}
}

int main()
{
	MGraph<char,int> G;
	G.CreateGraph();
	G.CheckCircle();
	system("pause");
	return 1;
}

    测试：

    有向图：

     

    结果：

    2、深度遍历 + 回溯

    思想：用回溯法,遍历时，如果遇到了之前访问过的结点，则图中存在环。

    代码：

    [cpp] view plain copy print ?
    1. #include <iostream>   
    2. using namespace std;  
    3. const int MAX_Vertex_Num = 20;  
    4. template<class VexType,class ArcType>  
    5. class MGraph  
    6. {  
    7. public:  
    8.     void CreateGraph();//创建图   
    9.     int LocateVex(VexType v);//返回顶点v所在顶点向量中的位置（下标）   
    10.     bool CheckCircle();//检查图中有无环   
    11. private:  
    12.     VexType vexs[MAX_Vertex_Num];//顶点向量   
    13.     ArcType arcs[MAX_Vertex_Num][MAX_Vertex_Num]; //这里把邻接矩阵类型用模板表示，主要是为了处理有权值的情况，比如：权值可以为小数（代价），也可以为整数   
    14.     int vexnum;//顶点数   
    15.     int arcnum;//边数   
    16. private:  
    17.     void CheckCircle(int u,bool& isExist,bool visited[MAX_Vertex_Num],bool Isvisited[MAX_Vertex_Num]);  
    18. };  
    19.   
    20. template<class VexType,class ArcType>  
    21. void MGraph<VexType,ArcType>::CreateGraph()  
    22. {  
    23.     VexType first;  
    24.     VexType Secend;  
    25.     cout<<"请输入顶点数:";  
    26.     cin>>vexnum;  
    27.     cout<<"请输入边数:";  
    28.     cin>>arcnum;  
    29.     cout<<"请输入各个顶点值：";  
    30.     for (int i=0;i<vexnum;i++)  
    31.     {  
    32.         cin>>vexs[i];  
    33.     }  
    34.     //初始化邻接矩阵   
    35.     for (int i=0;i<arcnum;i++)  
    36.     {  
    37.         for (int j=0;j<arcnum;j++)  
    38.         {  
    39.             arcs[i][j]=0;  
    40.         }  
    41.     }  
    42.     cout<<"请输入边的信息:"<<endl;  
    43.     for (int i=0;i<arcnum;i++)  
    44.     {  
    45.         cin>>first>>Secend;  
    46.         //如果边有权值的话，则还应该输入权值   
    47.         int x = LocateVex(first);  
    48.         int y = LocateVex(Secend);  
    49.         arcs[x][y]=1;//如果是有权的话，这里应该是arc[x][y]=权值   
    50.     }  
    51. }   
    52. /* 
    53. 参数：v：表示顶点向量中一个值 
    54. 函数返回值：函数返回v在顶点向量中的下标 
    55. */  
    56. template<class VexType,class ArcType>  
    57. int MGraph<VexType,ArcType>::LocateVex(VexType v)  
    58. {  
    59.     for (int i=0;i<vexnum;i++)  
    60.     {  
    61.         if (vexs[i]==v)  
    62.         {  
    63.             return i;  
    64.         }  
    65.     }  
    66.     return -1;  
    67. }  
    68.   
    69. /* 
    70. 思想：用回溯法,遍历时，如果遇到了之前访问过的结点，则图中存在环。 
    71. */  
    72. template<class VexType,class ArcType>  
    73. void MGraph<VexType,ArcType>::CheckCircle(int u,bool& isExist,bool visited[MAX_Vertex_Num],bool Isvisited[MAX_Vertex_Num])  
    74. {  
    75.     visited[u]=true;  
    76.     Isvisited[u]=true;  
    77.     for (int j=0;j<vexnum;j++)  
    78.     {  
    79.         if (arcs[u][j]==1)  
    80.         {  
    81.             if (visited[j]==false)  
    82.             {  
    83.                 CheckCircle(j,isExist,visited,Isvisited);  
    84.             }  
    85.             else  
    86.             {  
    87.                 isExist = true;  
    88.             }  
    89.         }  
    90.     }  
    91.     visited[u]=false;//回溯，如果不写就变成一半的深度遍历，不能进行判断是否有边存在   
    92. }  
    93.   
    94. template<class VexType,class ArcType>  
    95. bool MGraph<VexType,ArcType>::CheckCircle()  
    96. {  
    97.     bool isExist = false;  
    98.     bool Isvisited[MAX_Vertex_Num]={false};  
    99.     bool visited[MAX_Vertex_Num]={false};  
    100.     for (int i=0;i<vexnum;i++)  
    101.     {  
    102.         if (Isvisited[i]==false)  
    103.         {  
    104.             CheckCircle(i,isExist,visited,Isvisited);  
    105.             if (isExist)  
    106.             {  
    107.                 return true;  
    108.             }  
    109.         }  
    110.     }  
    111.     return isExist;  
    112. }  
    113.   
    114. int main()  
    115. {  
    116.     MGraph<char,int> G;  
    117.     G.CreateGraph();  
    118.     if (G.CheckCircle())  
    119.     {  
    120.         cout<<"图存在环！"<<endl;  
    121.     }  
    122.     else  
    123.     {  
    124.         cout<<"图不存在环！"<<endl;  
    125.     }  
    126.     system("pause");  
    127.     return 1;  
    128. }  
    #include <iostream>
using namespace std;
const int MAX_Vertex_Num = 20;
template<class VexType,class ArcType>
class MGraph
{
public:
	void CreateGraph();//创建图
	int LocateVex(VexType v);//返回顶点v所在顶点向量中的位置（下标）
	bool CheckCircle();//检查图中有无环
private:
	VexType vexs[MAX_Vertex_Num];//顶点向量
	ArcType arcs[MAX_Vertex_Num][MAX_Vertex_Num]; //这里把邻接矩阵类型用模板表示，主要是为了处理有权值的情况，比如：权值可以为小数（代价），也可以为整数
	int vexnum;//顶点数
	int arcnum;//边数
private:
	void CheckCircle(int u,bool& isExist,bool visited[MAX_Vertex_Num],bool Isvisited[MAX_Vertex_Num]);
};

template<class VexType,class ArcType>
void MGraph<VexType,ArcType>::CreateGraph()
{
	VexType first;
	VexType Secend;
	cout<<"请输入顶点数:";
	cin>>vexnum;
	cout<<"请输入边数:";
	cin>>arcnum;
	cout<<"请输入各个顶点值：";
	for (int i=0;i<vexnum;i++)
	{
		cin>>vexs[i];
	}
	//初始化邻接矩阵
	for (int i=0;i<arcnum;i++)
	{
		for (int j=0;j<arcnum;j++)
		{
			arcs[i][j]=0;
		}
	}
	cout<<"请输入边的信息:"<<endl;
	for (int i=0;i<arcnum;i++)
	{
		cin>>first>>Secend;
		//如果边有权值的话，则还应该输入权值
		int x = LocateVex(first);
		int y = LocateVex(Secend);
		arcs[x][y]=1;//如果是有权的话，这里应该是arc[x][y]=权值
	}
} 
/*
参数：v：表示顶点向量中一个值
函数返回值：函数返回v在顶点向量中的下标
*/
template<class VexType,class ArcType>
int MGraph<VexType,ArcType>::LocateVex(VexType v)
{
	for (int i=0;i<vexnum;i++)
	{
		if (vexs[i]==v)
		{
			return i;
		}
	}
	return -1;
}

/*
思想：用回溯法,遍历时，如果遇到了之前访问过的结点，则图中存在环。
*/
template<class VexType,class ArcType>
void MGraph<VexType,ArcType>::CheckCircle(int u,bool& isExist,bool visited[MAX_Vertex_Num],bool Isvisited[MAX_Vertex_Num])
{
	visited[u]=true;
	Isvisited[u]=true;
	for (int j=0;j<vexnum;j++)
	{
		if (arcs[u][j]==1)
		{
			if (visited[j]==false)
			{
				CheckCircle(j,isExist,visited,Isvisited);
			}
			else
			{
				isExist = true;
			}
		}
	}
	visited[u]=false;//回溯，如果不写就变成一半的深度遍历，不能进行判断是否有边存在
}

template<class VexType,class ArcType>
bool MGraph<VexType,ArcType>::CheckCircle()
{
	bool isExist = false;
	bool Isvisited[MAX_Vertex_Num]={false};
	bool visited[MAX_Vertex_Num]={false};
	for (int i=0;i<vexnum;i++)
	{
		if (Isvisited[i]==false)
		{
			CheckCircle(i,isExist,visited,Isvisited);
			if (isExist)
			{
				return true;
			}
		}
	}
	return isExist;
}

int main()
{
	MGraph<char,int> G;
	G.CreateGraph();
	if (G.CheckCircle())
	{
		cout<<"图存在环！"<<endl;
	}
	else
	{
		cout<<"图不存在环！"<<endl;
	}
	system("pause");
	return 1;
}

    结果测试：

     图：

     

    结果：

    3、深度遍历 + 判断后退边

    思想：用DFS（深度优先遍历）,判断是否有后退边，若有，则存在环

    具体来说，在遍历顶点的每一条边时，判断一下这个边的顶点是不是在栈中，如果在栈中，说明之前已经访问过了，这里再次访问，说明有环存在

    判断后退边时，借助一个栈和一个数组

    栈：即可以用来输出环

    数组：inStack判断是否在栈中

    源代码：

    [cpp] view plain copy print ?
    1. #include <iostream>   
    2. using namespace std;  
    3. const int MAX_Vertex_Num = 20;  
    4. template<class VexType,class ArcType>  
    5. class MGraph  
    6. {  
    7. public:  
    8.     void CreateGraph();//创建图   
    9.     int LocateVex(VexType v);//返回顶点v所在顶点向量中的位置（下标）   
    10.     void CheckCircle();  
    11. private:  
    12.     VexType vexs[MAX_Vertex_Num];//顶点向量   
    13.     ArcType arcs[MAX_Vertex_Num][MAX_Vertex_Num]; //这里把邻接矩阵类型用模板表示，主要是为了处理有权值的情况，比如：权值可以为小数（代价），也可以为整数   
    14.     int vexnum;//顶点数   
    15.     int arcnum;//边数   
    16. private:  
    17.     void DFS(int x,bool visited[MAX_Vertex_Num],int stack[MAX_Vertex_Num],int& top,bool inStack[MAX_Vertex_Num],int& count);  
    18.   
    19. };  
    20.   
    21. template<class VexType,class ArcType>  
    22. void MGraph<VexType,ArcType>::CreateGraph()  
    23. {  
    24.     VexType first;  
    25.     VexType Secend;  
    26.     cout<<"请输入顶点数:";  
    27.     cin>>vexnum;  
    28.     cout<<"请输入边数:";  
    29.     cin>>arcnum;  
    30.     cout<<"请输入各个顶点值：";  
    31.     for (int i=0;i<vexnum;i++)  
    32.     {  
    33.         cin>>vexs[i];  
    34.     }  
    35.     //初始化邻接矩阵   
    36.     for (int i=0;i<arcnum;i++)  
    37.     {  
    38.         for (int j=0;j<arcnum;j++)  
    39.         {  
    40.             arcs[i][j]=0;  
    41.         }  
    42.     }  
    43.     cout<<"请输入边的信息:"<<endl;  
    44.     for (int i=0;i<arcnum;i++)  
    45.     {  
    46.         cin>>first>>Secend;  
    47.         //如果边有权值的话，则还应该输入权值   
    48.         int x = LocateVex(first);  
    49.         int y = LocateVex(Secend);  
    50.         arcs[x][y]=1;//如果是有权的话，这里应该是arc[x][y]=权值   
    51.     }  
    52. }   
    53. /* 
    54. 参数：v：表示顶点向量中一个值 
    55. 函数返回值：函数返回v在顶点向量中的下标 
    56. */  
    57. template<class VexType,class ArcType>  
    58. int MGraph<VexType,ArcType>::LocateVex(VexType v)  
    59. {  
    60.     for (int i=0;i<vexnum;i++)  
    61.     {  
    62.         if (vexs[i]==v)  
    63.         {  
    64.             return i;  
    65.         }  
    66.     }  
    67.     return -1;  
    68. }  
    69.   
    70. /* 
    71. 检查图中是不是有回向边 
    72. 思想： 
    73. 如果有回向边，则无环，反之有环 
    74. */  
    75. template<class VexType,class ArcType>  
    76. void MGraph<VexType,ArcType>::CheckCircle()  
    77. {  
    78.     int count=0;//环的个数   
    79.     int top=-1;  
    80.     int stack[MAX_Vertex_Num];  
    81.     bool inStack[MAX_Vertex_Num]={false};  
    82.     bool visited[MAX_Vertex_Num]={false};  
    83.     for (int i=0;i<vexnum;i++)  
    84.     {  
    85.         if (!visited[i])  
    86.         {  
    87.             DFS(i,visited,stack,top,inStack,count);  
    88.         }  
    89.     }  
    90. }  
    91.   
    92. template<class VexType,class ArcType>  
    93. void MGraph<VexType,ArcType>::DFS(int x,bool visited[MAX_Vertex_Num],int stack[MAX_Vertex_Num],int& top,bool inStack[MAX_Vertex_Num],int& count)  
    94. {  
    95.     visited[x]=true;  
    96.     stack[++top]=x;  
    97.     inStack[x]=true;  
    98.     for (int i=0;i<vexnum;i++)  
    99.     {  
    100.         if (arcs[x][i]!=0)//有边   
    101.         {  
    102.             if (!inStack[i])  
    103.             {  
    104.                 DFS(i,visited,stack,top,inStack,count);  
    105.             }  
    106.             else //条件成立，表示下标为x的顶点到 下标为i的顶点有环   
    107.             {  
    108.                 count++;  
    109.                 cout<<"第"<<count<<"环为:";  
    110.                 //从i到x是一个环，top的位置是x，下标为i的顶点在栈中的位置要寻找一下   
    111.                 //寻找起始顶点下标在栈中的位置   
    112.                 int t=0;  
    113.                 for (t=top;stack[t]!=i;t--);  
    114.                 //输出环中顶点   
    115.                 for (int j=t;j<=top;j++)  
    116.                 {  
    117.                     cout<<vexs[stack[j]];  
    118.                 }  
    119.                 cout<<endl;  
    120.             }  
    121.         }  
    122.     }  
    123.     //处理完结点后，退栈   
    124.     top--;  
    125.     inStack[x]=false;  
    126. }  
    127. int main()  
    128. {  
    129.     MGraph<char,int> G;  
    130.     G.CreateGraph();  
    131.     G.CheckCircle();  
    132.     system("pause");  
    133.     return 1;  
    134. }  
    #include <iostream>
using namespace std;
const int MAX_Vertex_Num = 20;
template<class VexType,class ArcType>
class MGraph
{
public:
	void CreateGraph();//创建图
	int LocateVex(VexType v);//返回顶点v所在顶点向量中的位置（下标）
	void CheckCircle();
private:
	VexType vexs[MAX_Vertex_Num];//顶点向量
	ArcType arcs[MAX_Vertex_Num][MAX_Vertex_Num]; //这里把邻接矩阵类型用模板表示，主要是为了处理有权值的情况，比如：权值可以为小数（代价），也可以为整数
	int vexnum;//顶点数
	int arcnum;//边数
private:
	void DFS(int x,bool visited[MAX_Vertex_Num],int stack[MAX_Vertex_Num],int& top,bool inStack[MAX_Vertex_Num],int& count);

};

template<class VexType,class ArcType>
void MGraph<VexType,ArcType>::CreateGraph()
{
	VexType first;
	VexType Secend;
	cout<<"请输入顶点数:";
	cin>>vexnum;
	cout<<"请输入边数:";
	cin>>arcnum;
	cout<<"请输入各个顶点值：";
	for (int i=0;i<vexnum;i++)
	{
		cin>>vexs[i];
	}
	//初始化邻接矩阵
	for (int i=0;i<arcnum;i++)
	{
		for (int j=0;j<arcnum;j++)
		{
			arcs[i][j]=0;
		}
	}
	cout<<"请输入边的信息:"<<endl;
	for (int i=0;i<arcnum;i++)
	{
		cin>>first>>Secend;
		//如果边有权值的话，则还应该输入权值
		int x = LocateVex(first);
		int y = LocateVex(Secend);
		arcs[x][y]=1;//如果是有权的话，这里应该是arc[x][y]=权值
	}
} 
/*
参数：v：表示顶点向量中一个值
函数返回值：函数返回v在顶点向量中的下标
*/
template<class VexType,class ArcType>
int MGraph<VexType,ArcType>::LocateVex(VexType v)
{
	for (int i=0;i<vexnum;i++)
	{
		if (vexs[i]==v)
		{
			return i;
		}
	}
	return -1;
}

/*
检查图中是不是有回向边
思想：
如果有回向边，则无环，反之有环
*/
template<class VexType,class ArcType>
void MGraph<VexType,ArcType>::CheckCircle()
{
	int count=0;//环的个数
	int top=-1;
	int stack[MAX_Vertex_Num];
	bool inStack[MAX_Vertex_Num]={false};
	bool visited[MAX_Vertex_Num]={false};
	for (int i=0;i<vexnum;i++)
	{
		if (!visited[i])
		{
			DFS(i,visited,stack,top,inStack,count);
		}
	}
}

template<class VexType,class ArcType>
void MGraph<VexType,ArcType>::DFS(int x,bool visited[MAX_Vertex_Num],int stack[MAX_Vertex_Num],int& top,bool inStack[MAX_Vertex_Num],int& count)
{
	visited[x]=true;
	stack[++top]=x;
	inStack[x]=true;
	for (int i=0;i<vexnum;i++)
	{
		if (arcs[x][i]!=0)//有边
		{
			if (!inStack[i])
			{
				DFS(i,visited,stack,top,inStack,count);
			}
			else //条件成立，表示下标为x的顶点到 下标为i的顶点有环
			{
				count++;
				cout<<"第"<<count<<"环为:";
				//从i到x是一个环，top的位置是x，下标为i的顶点在栈中的位置要寻找一下
				//寻找起始顶点下标在栈中的位置
				int t=0;
				for (t=top;stack[t]!=i;t--);
				//输出环中顶点
				for (int j=t;j<=top;j++)
				{
					cout<<vexs[stack[j]];
				}
				cout<<endl;
			}
		}
	}
	//处理完结点后，退栈
	top--;
	inStack[x]=false;
}
int main()
{
	MGraph<char,int> G;
	G.CreateGraph();
	G.CheckCircle();
	system("pause");
	return 1;
}

    结果测试：

    有向图：

     

    结果：
     

     

    1. //求图中环的个数   
    2. //由于图中每个点的出度只有1，所以不存在一个点处于两个环的交点   
    3. //因此,求环的个数时每个只需要考虑一次便可得出结果   
    4. //由于数据规模庞大，写成递归形式容易暴栈   
    5. //在读边的过程中先对自环进行预处理，之后对每个点进行不同的染色，对它的下一个点也染同样的颜色   
    6. //这样染下去如果发现下一个要染的点和正在染的颜色相同，则说明存在一个环   
    7. //换染色起点的同时也需要更换新的染色，才能保证对环的判断正确   
    8. #include<iostream>   
    9. #include<cstring>   
    10. using namespace std;  
    11. int next[1000001];//指向下一结点的指针      
    12. int vis[1000001];//对每个结点进行不同的标记   
    13. int ans,n,ringID,p;  
    14. void search()  
    15. {  
    16.     for(int i = 1;i <= n;++i)  
    17.     {  
    18.         if(vis[i] > 0)   continue;  
    19.         p = i;  
    20.         ++ringID;//对每一种环进行一种不同的标记，新的起点必须更换新的染色   
    21.         while(vis[p] == 0)//当前结点未被染色   
    22.         {  
    23.             vis[p] = ringID;//染色   
    24.             p = next[p];//指向下一个点   
    25.             if(vis[p] == ringID)//下一个点的颜色和当前染色相同,则说明存在一个环   
    26.                 ++ans;  
    27.         }  
    28.     }  
    29. }  
    30. int main()  
    31. {  
    32.     //freopen("in.txt","r",stdin);   
    33.     while(scanf("%d",&n) != EOF)  
    34.     {  
    35.         ans = 0;  
    36.         ringID = 1;  
    37.         memset(vis,0,sizeof(vis));  
    38.         for(int i = 1;i <= n;++i)  
    39.         {  
    40.             scanf("%d",&next[i]);  
    41.             if(next[i] == i)  
    42.             {  
    43.                 vis[i] = ringID++;//先对自环进行预处理   
    44.                 ans++;  
    45.             }  
    46.         }  
    47.         search();  
    48.         printf("%d/n",ans);  
    49.     }  
    50.     return 0;  
    51. }  

     

     

环的寻找：寻找无向图中所有存在的环-删除点法
alppkk4545的博客
11-09 3179
此文讨论一个无向图中存在环的问题，在不管多复杂的连通图中寻找出所有的环，使用删除点的方法。 此外，这个版本的查找方法可以用于其他场景：找出无向图中所有的环的算法 结果能找到最小的环,或许要靠运气，输出该输出的环...............，这是原始算法。 改进： 可以输出最大...
判断无向图中环的个数 以及 每个环中的元素：（有错误，待修改）
思考，思考，再思考~
11-06 6209
VS2008可以运行通过。程序参考了许多大牛的总结，因能力有限，如有问题，请各位大牛指正。 存储结构：邻接矩阵（使用邻接表会比较麻烦--要删除每条边） 判断图中是否有环的思想： 如果存在回路，则必存在一个子图，是一个环路。环路中所有顶点的度>=2。 找出环个数和环中元素的思想：（有错误，待修改） 把度为1 的结点都删除后，剩下的均为环中元素，之后进行深度遍历，就可以得到连通分量 其中
2021-08-29：N * M的棋盘（N和M是输入参数），每种颜色的格子数必须相同的，上下左右的格子算相邻，相邻格子染的颜色必须不同，所有格子必须染色，返回至少多少种颜色可以完成任务。 福大大 答
福大大架构师每日一题
08-30 1万+
2021-08-29：N * M的棋盘（N和M是输入参数），每种颜色的格子数必须相同的，上下左右的格子算相邻，相邻格子染的颜色必须不同，所有格子必须染色，返回至少多少种颜色可以完成任务。 福大大 答案2021-08-29： 1.暴力法，看规律。 2.数学法。规律是N*M最小的质数因子就是需要的返回值。 代码用golang编写。代码如下： package main import "fmt" func main() { ret := minColors(4, 2) fmt.Println(r
判断有向图是否有环 、环的个数以及环中元素
xinanzhung的专栏
05-26 4627
判断有向图是否有环有三种方法：拓扑排序、深度遍历+回溯、深度遍历 + 判断后退边 这里使用 拓扑排序 和 深度遍历 + 回溯判断是不是环。使用 深度遍历 + 判断后退边找出环个数 以及环中元素 1、拓扑排序 思想：找入度为0的顶点，输出顶点，删除出边。循环到无顶点输出。 若：输出所有顶点，则课拓扑排序，无环；反之，则不能拓扑排序，有环 使用：可以使用拓扑排序为有向无环
有向图、无向图是否有环的判断
ddkxddkx的专栏
10-10 2787
这些算法和思想都是来自网上的，在此感谢原作者！ 先介绍一下无向图的判断算法，这个比较简单： 判断无向图中是否存在回路（环）的算法描述 如果存在回路，则必存在一个子图，是一个环路。环路中所有顶点的度>=2。 算法：      第一步：删
怎么判断一张图里是否有环
07-23
判断一张图里是否有环可以使用图的遍历算法，比如深度优先搜索（DFS）或广度优先搜索（BFS）。以下是一种基于DFS的判断方法： 1. 从图中的任意一个节点开始进行DFS遍历。 2. 在DFS过程中，维护一个访问标记数组，...
java判断有向图是否有环_判断有向图是否有环
weixin_42131013的博客
02-27 2640
方法一：拓扑排序时间复杂度O(n^2)比较常用的是用拓扑排序来判断有向图中是否存在环。什么是拓扑排序呢？我们先定义一条u到v的边e=,u生成拓扑序列的算法就叫拓扑排序啦~算法流程描述while(节点个数次(N)循环)1.找出入度为0的节点u(节点个数次(N)循环)2.删去这个节点u和从这个节点出发相连的边(,....,)，更新这些边连的点(v1,v2,v3....vn)的入度信息。3.直到找不到入...
判断一个图是否有环
大西瓜不甜的博客
09-27 1558
对于无向图 算法1 我们知道对于环1-2-3-4-1，每个节点的度都是2，基于此我们有如下算法（这是类似于有向图的拓扑排序）： 求出图中所有顶点的度， 删除图中所有度<=1的顶点以及与该顶点相关的边，把与这些边相关的顶点的度减一 如果还有度<=1的顶点重复步骤2 最后如果还存在未被删除的顶点，则表示有环；否则没有环 时间复杂度为O（E+V），其中E、V分别为图中边和顶点的数目，这个算法我们稍后分析算法3的时候再分析。 算法2 深度优先遍历该图，如果在遍历的过程中，发现某个节.
java用广度优先的方法来判断有向图是否有环
跳币上山岭的博客
08-16 2704
这里的代码参考了很多别人的代码和文章。。 今天师兄做笔试题，我也跟着看，碰到了一个要构建有向图并判断节点是否有环的题。 另一位师兄说这个题可以用并查集做，并且做出来了，我用并查集试了试做不出来。。 我觉得这题大概是要用有向图做，考察有向图的构建及寻找有向环 但是我只会对着书本抄代码构建有向图，不会寻找环，就尝试了一下用前不久做爬虫用到的广度遍历来寻找有向环。。
课程表（LeetCode/判断有向图是否有环/拓扑排序/dfs）
weixin_44164489的博客
09-15 834
CSP认证的第三题遇到了判断环的问题，当时用了dfs求解，样例跑出来了，可是还是拿不到后面50分。。。
数据结构源代码——邻接矩阵
06-17
图的邻接矩阵的表示及各种操作，比如找图中第 i 个结点的第一个邻结点，深度优先遍历（递规），以结点P为根创建深度优先生成树（递归），建立深度优先生成森林，前序输出生成森林（孩子兄弟表示法），PRIM算法构造最小代价生成树,从某结点开始，迪杰斯特拉算法求最短路径(无向图)
邻接矩阵ＣＰＰ文件
11-16
#include "stdafx.h" #include<stdio.h> #include"stdlib.h" #include<math.h> #include "iostream.h" #include "time.h" #define INFINITY 100 //最大值100 #define MAX_VERTEX_NUM 20 //最大定点个数 //邻接矩阵的定义 typedef struct ArcCell //弧结构定义 { int adj; //表示相邻否，对带权图，则为权值的类型 char *info; //该弧相关信息的指针 } ArcCell,AdjMatrix[100 ][100]; typedef struct //图结构的定义 { char vexs[20]; //定点向量 AdjMatrix arcs;
数据结构课程设计-图的邻接矩阵.cpp
10-25
随着计算机的普及,信息的存储逐渐和我们的日常生活变得密切起来，而数据的存储方式也多种多样，比如树、链表、数组、图等等。 为了充分体现图的矩阵储存结构的优势与功能，要求本系统应达到以下要求： 1. 图是无向带权图 2. 能从键盘上输入各条边和边上的权值； 3. 构造图的邻接矩阵和顶点集。 4. 输出图的各顶点和邻接矩阵 5. 插入一条边 6. 删除一条边 7. 求出各顶点的度 8. 判断该图是否是连通图，若是，返回1；否则返回0. 9. 使用深度遍历算法，输出遍历序列
判断图中是否有环的三种方法
热门推荐
CC
09-04 5万+
0 什么是环？ 在图论中，环（英语：cycle）是一条只有第一个和最后一个顶点重复的非空路径。 在有向图中，一个结点经过两种路线到达另一个结点，未必形成环。 1 拓扑排序 1.1 无向图 使用拓扑排序可以判断一个无向图中是否存在环，具体步骤如下： 求出图中所有结点的度。 将所有度 <= 1 的结点入队。（独立结点的度为 0） 当队列不空时，弹出队首元素，把与队首元素相邻节点的度减一。如果相邻节点的度变为一，则将相邻结点入队。 循环结束时判断已经访问的结点数是否等于 n。等于 n 说明全部结点都.
判断一个有向图是否有环
Cainiao
12-22 1万+
Description 给出一个有向图，判断图中是否存在回路。 Input 第1行：输入图的顶点个数N（1 ≤ N≤ 2,500）和C（图的边数，1 ≤ C ≤ 6,200）； 第2到C+1行中，第i+1行输入两个整数，分别表示第i条边的起点和终点的编号。 Output 如果图中存在回路，输出“YES”，否则，输出“NO”。 Sample Input 7
查找有向图中所有的环
weixin_34194359的博客
06-30 6059
在对每个结点进行DFS的基础上进行了一些优化。 优化原理：在findCycle(v,e) 中访问过的点，不再进行findCycle(). 因为这些点若还构成有其它的环，那么在递归到该点时会查找出来。 本方法中输出的环，结点不是按其在环中的先后位置排列的。 1 import java.util.*; 2 3 public class GetAllCyclesForDire...
判断一个图是否有环 无向图 有向图
xwdreamer的专栏
06-11 2万+
没有找到原文出处，请参考一下链接：http://www.cnblogs.com/hiside/archive/2010/12/01/1893878.htmlhttp://topic.youkuaiyun.com/u/20071023/11/3edb81fc-37b2-4506-906e-44dc0fc521f2.html一、无向图：方法1：如果存在回路，则必存在一个子图，是一个环路。环路中
对有向图的环的判定，并且输出图中所有的路径 C++算法
小屋
09-11 1万+
说明：我们选择的图是有向图，图的存储方式是邻接矩阵，使用C++语言，基于vs2010平台 算法思想：逐个对图中的出度不为0的点进行遍历。假如是先对图A节点进行遍历：首先，将A节点所连接的点存储在数组vect1中，然后对A节点进栈，并对A节点的连接点进行深度优先。当节点的出度为0时，出栈，出栈的时候判断该节点是不是在vec1中的元素，如果是则为环，若不是则不是环。  代码： #incl
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值