中国邮路问题编程求解

中国邮路问题(Chinese Postman Problem)是一个非常经典的图论问题:一个邮递员送信,要走完他负责投递的全部街道(所有街道都是双向通行的且每条街道可以经过不止一次),完成任务后回到邮局,应按怎样的路线走,他所走的路程才会最短呢?如果将这个问题抽象成图论的语言,就是给定一个连通图,每条边的权值就是街道的长度,本问题转化为在图中求一条回路,使得回路的总权值最小。

如果街道的连通图为欧拉图,则只要求出图中的一条欧拉回路即可。否则,邮递员要完成任务就必须在某些街道上重复走若干次。如果重复走一次,就加一条平行边,于是原来对应的图形就变成了多重图。只是要求加进的平行边的总权值最小就行了。于是,我们的问题就转化为,在一个有奇度数结点的赋权连通图中,增加一些平行边,使得新图不含奇度数结点,并且增加的边的总权值最小。

求所增加边总权值最小的方案,需要我们找出所有奇度顶点(偶数个)来两两分组,对每小组中的两个点求其最短路径,进而求出每分组的总权值。对所有分组情况,找出最小权值即是最佳方案。

下面直接上源代码。

#include 

#include 
#include 
#include 
#include 

using namespace std;

#define MAX_NODE 26 // 最大结点数
#define COST_NO_LINK	INT_MAX // 定义结点之间没有连接的花销为INT_MAX吗

int Graph[MAX_NODE][MAX_NODE];
int Cost[MAX_NODE][MAX_NODE];
int V_dingdianshu, E_bianshu, Start_Point; // 顶点数和边数,以及开始的起点(以0开始)

int Odd_Grouping[MAX_NODE]; // 为0表示不为奇,为1表示为奇,从2开始表示配对分组情况,如同为2的两个为一组,同为3的两个为一组,……
int Bak_Odd_Grouping[MAX_NODE]; // 最好情况下分组策略的备份,因为可能还有其他情况更好,如果有,就更新此备份。
int SHORTEST_PATH_WEIGHT(COST_NO_LINK); // 如果存在奇度数点,这里是记录的添加最短路径的最小值,是所有点两两分组的最短路径之和的最小值。此值对应Bak_Odd_Grouping所描述的分组情况。

int Dist[MAX_NODE]; // Dijstra算法中,求从v0到v1最短路径结果,里面包含v0到最短路径上各点的最短权值
int ShortCache[MAX_NODE][MAX_NODE]; // Dijstra算法中,求点v0到v1的最短路径记录值,当第一次求时,把结果存到本数组中,下次如果还在相同调用,则直接返回本数组中相应值。

// 数据输入,会用到Graph和Cost
void Input()
{
	int i, j;
	int m, n;
	char cs, cm, cn;
	int w;

	cout << "输入图的顶点数:";
	cin >> V_dingdianshu;
	cout << "输入图边的数目:";
	cin >> E_bianshu;
	cout << "输入起点:";
	cin >> cs;
	Start_Point = cs - 'a';
	for(i = 0; i < V_dingdianshu; i++)
	{
		for(j = 0; j < V_dingdianshu; j++)
		{
			Graph[i][j] = 0;
			ShortCache[i][j] = 0;
			Cost[i][j] = COST_NO_LINK;
		}
		Cost[i][i] = 0; // 置自己到自己为0
	}

	cout << "输入" << E_bianshu << "条边对应的顶点和权值(顶点从a开始编号):" << endl;
	for(i = 0; i < E_bianshu; i++)
	{
		cin >> cm >> cn >> w;
		m = cm - 'a';
		n = cn - 'a';
		Graph[m][n] += 1;
		Graph[n][m] += 1;
		Cost[m][n] = w;
		Cost[n][m] = w;
	}
}

// 对图G从v0点开始到v1点算到必要各点的最短距离,结果保存在dist上面。因此不保证dist上的所有数据都是正确的(保证dist[v]是从v0到v的最短距离)
// 第三个参数指定是否使用Cache值,如果为真,则一般Dist的值不与当前调用相对应,反之则保证dist[v]是从v0到v的最短距离
// 返回dist[v1],即v0到v1的最短距离值
int Dijstra(int v0, int v1, bool useCache)
{
	if(useCache && ShortCache[v0][v1] != 0) // 之前计算过了,直接返回值
	{
		return ShortCache[v0][v1];
	}

	int i, s, w, min, minIndex;
	bool Final[MAX_NODE];

	// 初始化最短路径长度数据,所有数据都不是最终数据 
	for (s = 0; s < V_dingdianshu; s++)
	{
		Final[s] = false;
		Dist[s] = COST_NO_LINK; // 初始最大距离
	}
	// 首先选v0到v0的距离一定最短,最终数据 
	Final[v0] = true;
	Dist[v0] = 0;
	s = v0; // 0 预先选中v0点

	for (i = 0; i < V_dingdianshu; i++)
	{
		// 1 更新该点到其他未选中点的最短路径
		for(w = 0; w < V_dingdianshu; w++)
		{
			if(!Final[w] // w点未选中
				&& Cost[s][w] < COST_NO_LINK // 更新点应该与选中点s相连
				&& Dist[w] > Dist[s] + Cost[s][w]) // 通过点s会有更短的路径
			{
				if(Dist[s] + Cost[s][w] <= 0)
				{
					cout << "求最短路径数据溢出。" << endl;
					exit(-1);
				}
				Dist[w] = Dist[s] + Cost[s][w];
			}
		}
		// 1.5 如果在中间过程找到了目标点v1,则不再继续计算了
		if(s == v1)
		{
			ShortCache[v0][v1] = Dist[s];
			ShortCache[v1][v0] = Dist[s];
			return Dist[s];
		}
		// 2 选中相应点
		min = COST_NO_LINK;
		for(w = 0; w < V_dingdianshu; w++)
		{
			if(!Final[w] // 未选中
				&& Dist[w] < min) // 值更小
			{
				minIndex = w;
				min = Dist[w];
			}
		}
		s = minIndex;
		Final[s] = true;
	}
	cerr << "程序异常。。。应该早找到了最短路径的" << endl;
	exit(-1);
}

// 图的连通性测试
// 参数start用于指定从哪个点开始找(索引从0开始),这样在一定程序上可以提高程序效率
// 空图返回真
// 这里对start功能的定义还应该加上:start点一定要在连通图上
bool ConnectivityTest(int start, bool& bNoPoints)
{
	set nodeSet; // 连通顶点集
	vector for_test_nodes; // 与新加入连通点连通的未加入点集
	int i, j;
	set singlePoints; // 图中的单点集

	// 先找出单点
	bool hasEdge = false;
	for(i = 0; i < V_dingdianshu; i++)
	{
		hasEdge = false;
		for(j = 0; j < V_dingdianshu; j++) // 这里起始应该是0,不然最后一个点如果是单点则无法判断
		{
			if (Graph[i][j] > 0)
			{
				hasEdge = true;
				break;
			}			
		}
		if (!hasEdge)
		{
			singlePoints.insert(i);
		}
	}

	bNoPoints = (singlePoints.size() == V_dingdianshu); // 设置bNoPoints标志

	if(singlePoints.find(start) != singlePoints.end()) // start点必须在连通图中
	{
		return false;
	}
	for_test_nodes.push_back(start); // 

	while(for_test_nodes.size() > 0)
	{
		int testNode = for_test_nodes.back();
		for_test_nodes.pop_back();

		for(i = 0; i < V_dingdianshu; i++)
		{
			if(Graph[testNode][i] > 0)
			{
				if(nodeSet.insert(i).second)
				{
					for_test_nodes.push_back(i);
				}
			}
		}
	}

	for(i = 0; i < V_dingdianshu; i++)
	{
		if (singlePoints.find(i) == singlePoints.end()
			&& nodeSet.find(i) == nodeSet.end())
			// 存在点既不是单点,也不在当前连通顶点集中,则这个点一定在其他连通子图中,返回假
		{
			return false;
		}
	}

	return true;
}

// 测试图中是否有度为奇的顶点,结果保存在中,返回奇度顶点数
int OddTest()
{
	int i, j, rSum, count;

	// 初始化
	for(i = 0; i < V_dingdianshu; i++)
	{
		Odd_Grouping[i] = 0; // 0表示不为奇
		Bak_Odd_Grouping[i] = 0;
	}
	count = 0;

	for(i = 0; i < V_dingdianshu; i++)
	{
		rSum = 0;
		for(j = 0; j < V_dingdianshu; j++)
		{
			rSum += Graph[i][j]; // 求i行和
		}
		if(rSum % 2 == 1)
		{
			Odd_Grouping[i] = 1;
			count++;
		}
	}

	return count;
}

void Bak_Grouping()
{
	int i;
	for(i = 0; i < V_dingdianshu; i++)
	{
		Bak_Odd_Grouping[i] = Odd_Grouping[i];
	}
}

// 对奇度顶点进行分组,level值从2开始取值。
// 返回值表示当前这种分组是否是当前所找到中的最好分组。本程序中没有采用其返回值。
bool Grouping(int level)
{
	if(level < 2)
	{
		cerr << "小于2的level值是不允许的。" << endl;
		exit(-1);
	}

	int i, j, findI = -1;
	for(i = 0; i < V_dingdianshu; i++)
	{
		if(Odd_Grouping[i] == 1)
		{
			Odd_Grouping[i] = level; // 找到第一个组合点。
			findI = i;
			break;
		}
	}

	bool re = true;
	if(findI == -1)  // 这里是形成一对新的组合后的地方,此时应该计算各组合最小路径之和。
	{
		int weightSum = 0;
		for(i = 2; i < level; i++) // 根据level的值可以知道分组的取值是从2到level-1的,所以i如是计数
		{
			int index[2];
			int *pIndex = index;
			for(j = 0; j < V_dingdianshu; j++)
			{
				if(Odd_Grouping[j] == i)
				{
					*pIndex = j;
					if(pIndex == index + 1) // 设置了第二个index值
					{
						break;
					}
					pIndex++;
				}
			}
			weightSum += Dijstra(index[0], index[1], true); // 这里暂时只计算最短路权值和,不实际上添加边,最后才添加。这样加边计算只会调用一次。
		}

		if(weightSum < SHORTEST_PATH_WEIGHT) // 当前组合比以往要优,将当前的排列组合情况更新到全局
		{
			Bak_Grouping(); // 如果当前分组比以往都好,备份一下
			SHORTEST_PATH_WEIGHT = weightSum;
			return true; // 找到了更优组合,返回递归调用为真
		}
		else
		{
			return false; // 没找到了更优组合,返回递归调用为假
		}
	}
	else if(findI > -1)
	{
		// 上面找到了第一个点了,现在从上面继续找第二个点。
		for(/* 继续上面的for */; i < V_dingdianshu; i++)
		{
			if(Odd_Grouping[i] == 1) // 找到第二个点
			{
				Odd_Grouping[i] = level;
				re = Grouping(level + 1);
				Odd_Grouping[i] = 1; // 无论当前分组是不是当前最好分组,我们都还要继续查找剩余分组情况
			}
		}
	}
	else
	{
		cerr << "findCount值异常" << endl;
		exit(-1);
	}

	if(findI > -1)
	{
		Odd_Grouping[findI] = 1; // 无论当前分组是不是最好分组,我们都还要继续查找剩余分组情况
	}

	return re;
}

void AddShortPath(int from, int to)
{
	int i, back;

	Dijstra(from, to, false); // 求最短路径,结果在dist数组中
	back = to;
	while(back != from) // from ... back ... to
	{
		for(i = 0; i < V_dingdianshu; i++)
		{
			if(i != back
				&& Dist[i] < COST_NO_LINK // from有边到i
				&& Dist[back] < COST_NO_LINK // from有边到back
				&& Dist[i] + Cost[i][back] == Dist[back]) // from通过中继点i再到back的长度恰好等于from到back的长度,即证明点i在最短路径上(注,这里如果(i,back)没有边连接,那么Dist[i] + Cost[i][back]一定为负数)
			{
				Graph[i][back]++; // 添加一条边
				Graph[back][i]++;
				back = i;
				break;
			}
		}
		if(i == V_dingdianshu) // 编程常识:这里break后不会再执行++
		{
			cerr << "程序异常,最短路径出问题了。。。" << endl;
			exit(-1);
		}
	}
}

// 根据odd数组的分组情况添加最短路径
void AddShortPaths()
{
	int i, j;

	for(i = 0; i < V_dingdianshu; i++)
	{
		if(Bak_Odd_Grouping[i] > 1)
		{
			for(j = i + 1; j < V_dingdianshu; j++)
			{
				if(Bak_Odd_Grouping[j] == Bak_Odd_Grouping[i])
				{
					AddShortPath(i, j);
					break;
				}
			}
		}
	}
}

// 处理图中可能存在度为奇的情况
void OddDeal()
{
	// 判断是否存在为奇的点,有的话要处理
	int oddCount = OddTest();
	if(oddCount > 0)
	{
		if(oddCount % 2 == 1)
		{
			cerr << "这是一个奇怪的图,存在奇数个奇度顶点的连通图吗?" << endl;
			exit(-1);
		}
		
		// 对为奇的点进行排列组合。。。
		Grouping(2); // 这里得到的odd2是最优的
		AddShortPaths(); // 根据odd数组添加最短路径
	}
}

/*
用Fleury算法求最短欧拉回游
假设迹wi=v0e1v1…eivi已经选定,那么按下述方法从E-{e1,e2,…,ei}中选取边ei+1:
1)、 ei+1与vi+1相关联;
2)、除非没有别的边可选择,否则 ei+1不能是Gi=G-{e1,e2,…,ei}的割边。
3)、 当(2)不能执行时,算法停止。
*/
void Fleury(int start)
{
	int i;
	int vi = start; // v0e1v1…eivi已经选定
	bool bNoPoints, bCnecTest;
	cout << "你要的结果:";
	while(true)
	{
		// 找一条不是割边的边ei+1
		for(i = 0; i < V_dingdianshu; i++)
		{
			if (Graph[vi][i] > 0)
			{
				// 假设选定(vi,i)这条边
				Graph[vi][i]--; // 这里会破坏全局Graph的值,但暂时没影响了,都不用了。
				Graph[i][vi]--;
				bCnecTest = ConnectivityTest(i, bNoPoints);
				if(!bNoPoints && !bCnecTest) // 这里一定要传i,这是欲选择边的末端,它应该在连通图中
				{
					Graph[vi][i]++;
					Graph[i][vi]++;
					continue;
				}
				// 选定(vi,i)这条边
				cout << (char)('a' + vi) << "-" << (char)('a' + i) << " ";
				vi = i;
				break;
			}			
		}
		if (i == V_dingdianshu)
		{
			cout << endl;
			break; // 这里应该是说边找完了
		}
	}
}

int main()
{
	Input();

	bool b;
	if(!ConnectivityTest(0, b)) // b是无用变量,这里不看。
	{
		cout << "该图不是连通图!\n";
		exit(0);
	}
	OddDeal(); // 处理可能的奇度点情况
	Fleury(Start_Point); // 这里应该用这个算法求欧拉回游
	
	return 0;
}

转载于:https://www.cnblogs.com/guocai/archive/2012/07/08/2581979.html

你可能感兴趣的:(中国邮路问题编程求解)