C++求图任意两点间的所有路径

基于连通图,邻接矩阵实现的图,非递归实现。

算法思想:

设置两个标志位,①该顶点是否入栈,②与该顶点相邻的顶点是否已经访问。

  A 将始点标志位①置1,将其入栈

  B 查看栈顶节点V在图中,有没有可以到达、且没有入栈、且没有从这个节点V出发访问过的节点

  C 如果有,则将找到的这个节点入栈,这个顶点的标志位①置1,V的对应的此顶点的标志位②置1

  D 如果没有,V出栈,并且将与v相邻的全部结点设为未访问,即全部的标志位②置0

  E 当栈顶元素为终点时,设置终点没有被访问过,即①置0,打印栈中元素,弹出栈顶节点

  F 重复执行B – E,直到栈中元素为空

先举一个例子吧


假设简单连通图如图1所示。假设我们要找出结点3到结点6的所有路径,那么,我们就设结点3为起点,结点6为终点。找到结点3到结点6的所有路径步骤如下:
1、 我们建立一个存储结点的栈结构,将起点3入栈,将结点3标记为入栈状态;
2、 从结点3出发,找到结点3的第一个非入栈没有访问过的邻结点1,将结点1标记为入栈状态,并且将3到1标记为已访问;
3、 从结点1出发,找到结点1的第一个非入栈没有访问过的邻结点0,将结点0标记为入栈状态,并且将1到0标记为已访问
4、 从结点0出发,找到结点0的第一个非入栈没有访问过的邻结点2,将结点2标记为入栈状态,并且将0到2标记为已访问
5、 从结点2出发,找到结点2的第一个非入栈没有访问过的邻结点5,将结点5标记为入栈状态,并且将2到5标记为已访问
6、 从结点5出发,找到结点5的第一个非入栈没有访问过的邻结点6,将结点6标记为入栈状态,并且将5到6标记为已访问
7、 栈顶结点6是终点,那么,我们就找到了一条起点到终点的路径,输出这条路径;
8、 从栈顶弹出结点6,将6标记为非入栈状态;
9、 现在栈顶结点为5,结点5没有非入栈并且非访问的结点,所以从栈顶将结点5弹出,并且将5到6标记为未访问
10、        现在栈顶结点为2,结点2的相邻节点5已访问,6满足非入栈,非访问,那么我们将结点6入栈;
11、        现在栈顶为结点6,即找到了第二条路径,输出整个栈,即为第二条路径
12、        重复步骤8-11,就可以找到从起点3到终点6的所有路径;
13、        栈为空,算法结束。

下面讲一下C++代码实现

图类,基于邻接矩阵,不详细的写了 ==

class Graph
{
private:
	CArray<DataType,DataType> Vertices;
	int Edge[MaxVertices][MaxVertices];
	int numOfEdges;
public:
	Graph();
	~Graph();
	void InsertVertex(DataType Vertex);
	void InsertEdge(int v1,int v2,int weight);
	int GetWeight(int i,int j);
	int GetVertices();
	DataType GetValue(int i);
};

首先自己写一个简单的“栈类”,由于新增了些方法所以不完全叫栈

template<class T>
class Stack
{
private:
	int m_size;
	int m_maxsize;
	T* data;
public:
	Stack();
	~Stack();
	void push(T data);  //压栈
	T pop(); //出栈,并返回弹出的元素
	T peek(); //查看栈顶元素
	bool isEmpty();  //判断是否空
	int getSize();  //得到栈的中元素个数
	T* getPath();  //返回栈中所有元素
};
template<class T>
Stack<T>::Stack()
{
	m_size=0;
	m_maxsize=100;
	data=new T[m_maxsize];
}
template<class T>
Stack<T>::~Stack()
{
	delete []data;
}
template<class T>
T Stack<T>::pop()
{
	m_size--;
	return data[m_size];
}

template<class T>
void Stack<T>::push(T d)
{
	if (m_size==m_maxsize)
	{
		m_maxsize=2*m_maxsize;
		T* new_data=new T[m_maxsize];
		for (int i=0;i<m_size;i++)
		{
			new_data[i]=data[i];
		}
		delete []data;
		data=new_data;
	}
	data[m_size]=d;
	m_size++;
}

template<class T>
T Stack<T>::peek()
{
	return data[m_size-1];
}

template<class T>
bool Stack<T>::isEmpty()
{
	if (m_size==0)
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

template<class T>
T* Stack<T>::getPath()
{
	T* path=new T[m_size];
	for (int i=0;i<m_size;i++)
	{
		path[i]=data[i];
	}
	return path;
}

template<class T>
int Stack<T>::getSize()
{
	return m_size;
}

Vertex类,便于遍历全部的结点

</pre><pre name="code" class="cpp">
class CVertex  
{
private:
	int m_num;//保存与该顶点相邻的顶点个数
	int *m_nei; //与该顶点相邻的顶点序号
	int *m_flag; //与该顶点相邻的顶点是否访问过
	bool isin; //该顶点是否入栈
public:
	CVertex();
	void Initialize(int num,int a[]);
	int getOne(); //得到一个与该顶点相邻的顶点
	void resetFlag(); //与该顶点相邻的顶点全被标记为未访问
	void setIsin(bool);//标记该顶点是否入栈
	bool isIn();  //判断该顶点是否入栈
	void Reset();//将isin和所有flag置0
    ~CVertex();

};

CVertex::CVertex()
{
	m_num=SIZE;
	m_nei=new int[m_num];
	m_flag=new int[m_num];
	isin=false;
	for (int i=0;i<m_num;i++)
	{
		m_flag[i]=0;
	}
	
}
void CVertex::Initialize(int num,int a[])
{
	m_num=num;
	for (int i=0;i<m_num;i++)
	{
		m_nei[i]=a[i];
	}
}
CVertex::~CVertex()
{
	delete []m_nei;
	delete []m_flag;
}
int CVertex::getOne()
{
	int i=0;
	for (i=0;i<m_num;i++)
	{
		if (m_flag[i]==0)   //判断是否访问过
		{
			m_flag[i]=1;   //表示这个顶点已经被访问,并将其返回
			return m_nei[i];
		}
	}
	return -1;  //所有顶点都已访问过则返回-1
}
void CVertex::resetFlag()
{
	for (int i=0;i<m_num;i++)
	{
		m_flag[i]=0;
	}
}
void CVertex::setIsin(bool a)
{
	isin=a;
}
bool CVertex::isIn()
{
	return isin;
}
void CVertex::Reset()
{
	for (int i=0;i<m_num;i++)
	{
		m_flag[i]=0;
	}
	isin=false;
}
初始化顶点类
        int a[SIZE],num;
	for ( i=0;i<SIZE;i++)
	{
		num=0;
		for (int j=0;j<SIZE;j++)
		{
			
			if (m_graph.Edge[i][j]!=MaxWeight&&i!=j)
			{
				a[num]=j;
				num++;
			}
			
		}
		vertex[i].Initialize(num,a);
	}


算法实现(由于是基于MFC实现,所有下边的代码不可以直接使用)
        stack.push(selection1); //将起点压栈
	vertex[selection1].setIsin(true);  //标记为已入栈
	int path_num=0;
	while (!stack.isEmpty())  //判断栈是否空
	{ 
		
		int flag=vertex[stack.peek()].getOne();  //得到相邻的顶点
		if (flag==-1)    //如果相邻顶点全部访问过  
		{
			int pop=stack.pop(); //栈弹出一个元素
			vertex[pop].resetFlag();  //该顶点相邻的顶点标记为未访问
			vertex[pop].setIsin(false); //该顶点标记为未入栈
			continue; //取栈顶的相邻节点
		} 
		if (vertex[flag].isIn())  //若已经在栈中,取下一个顶点
		{
			continue;
		}
		if (stack.getSize()>maxver-1) //判断栈中个数是否超过了用户要求的 ,这里是限制了一条路径节点的最大个数
		{
			int pop=stack.pop();
			vertex[pop].resetFlag();
			vertex[pop].setIsin(false);
			continue;
		}
		stack.push(flag); //将该顶点入栈
		
		vertex[flag].setIsin(true);  //记为已入栈
		
		if (stack.peek()==selection2)   //如果栈顶已经为所求,将此路径记录
		{
		   int *path=stack.getPath();
	           //保存路径的代码省略
		   int pop=stack.pop(); //将其弹出,继续探索
	           vertex[pop].setIsin(false); //清空入栈的标志位
		}
		
	}

由于用MFC实现的程序,上边一些变量的定义都没写,见谅。
附上 MFC程序下载地址,除了全部路径还实现了迪杰斯特拉算法和费洛伊德算法求最短路径,需要的可以下载一下,需要积分==

  • 16
    点赞
  • 45
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
以下是使用Bellman-Ford算法求解任意两点限制路径长度的最短距离的C++代码,其包含详细注释: ```c++ #include <iostream> #include <vector> #include <cstring> using namespace std; const int INF = 0x3f3f3f3f; // 定义无穷大 struct Edge { int from, to, weight; }; vector<Edge> edges; // 存储边的信息 int dist[100]; // 存储最短距离 int path[100]; // 存储路径 // n: 图节点的个数;s: 起点;t: 终点;maxLen: 路径长度限制 bool bellman_ford(int n, int s, int t, int maxLen) { memset(dist, INF, sizeof(dist)); // 初始化最短距离为无穷大 memset(path, -1, sizeof(path)); // 初始化路径为-1 dist[s] = 0; // 起点到起点的最短距离为0 // 进行n-1次松弛操作 for (int i = 0; i < n - 1; i++) { for (int j = 0; j < edges.size(); j++) { Edge e = edges[j]; if (dist[e.from] != INF && dist[e.from] + e.weight <= maxLen && dist[e.from] + e.weight < dist[e.to]) { dist[e.to] = dist[e.from] + e.weight; // 更新最短距离 path[e.to] = e.from; // 记录路径 } } } // 检查是否存在负权环 for (int i = 0; i < edges.size(); i++) { Edge e = edges[i]; if (dist[e.from] != INF && dist[e.from] + e.weight <= maxLen && dist[e.from] + e.weight < dist[e.to]) { return false; // 存在负权环,返回false } } return dist[t] != INF; // 如果dist[t]为INF,则表示起点s无法到达终点t } // 输出从起点到终点的最短路径 void print_path(int s, int t) { if (s == t) { cout << s; return; } if (path[t] == -1) { cout << "No path exists." << endl; return; } print_path(s, path[t]); cout << "->" << t; } int main() { int n = 5; // 节点数 int s = 0, t = 4; // 起点和终点 int maxLen = 7; // 路径长度限制 edges.push_back({0, 1, 2}); edges.push_back({0, 3, 4}); edges.push_back({1, 2, 3}); edges.push_back({2, 4, 1}); edges.push_back({3, 2, -2}); edges.push_back({3, 4, 2}); if (bellman_ford(n, s, t, maxLen)) { cout << "The shortest path from " << s << " to " << t << " with length <= " << maxLen << " is: "; print_path(s, t); cout << endl; } else { cout << "There is a negative cycle." << endl; } return 0; } ``` 这份代码,我们使用了一个结构体Edge来存储边的信息,包括起点from、终点to和权值weight。我们先将所有边的信息存储在一个vector,然后通过调用bellman_ford函数来计算最短距离。该函数的输入参数包括:节点数n、起点s、终点t和路径长度限制maxLen。如果存在一条从起点s到终点t的路径,其长度不超过maxLen,则返回true,并输出从起点到终点的最短路径;否则返回false,表示不存在这样的路径。在函数内部,我们使用dist数组来存储最短距离,path数组来存储路径。在进行n-1次松弛操作之后,我们再进行一次循环来检查是否存在负权环。最后,我们通过调用print_path函数来输出从起点到终点的最短路径

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值