最短路径和矩阵乘法-CSDN博客

本文链接：https://blog.csdn.net/ll393595574/article/details/122080259

介绍

这里讲的顶点对之间的最短路径是基于动态规划在图中的实现。每一个循环都类似矩阵乘法，因此这个算法看起来就像是一直在做矩阵乘法。

实现

在这里我们用邻接矩阵表示法来表示一个图，因为相对邻接表来说，邻接矩阵表示要容易些，并且采用自底而下的算法来计算最短路径权重。

typedef int (*Metrix)[VERTEX_NUMBER];

void printfMatrix(Metrix graphmetrix)
{
	for (int x = 0; x < VERTEX_NUMBER; ++ x)
	{
		for (int y = 0; y < VERTEX_NUMBER; ++ y)
		{
			cout << "\t" << graphmetrix[x][y] << " ";
		}
		cout << endl;
	}
	cout << endl;
}

这是输出一个图的矩阵表示法，其中的每个值表示当中两个顶点之间的权重值。

int getSentinel()
{
	return 0x7fffffff;
}

Metrix entendShortestPaths(Metrix left, Metrix right)
{
	const int n = VERTEX_NUMBER;
	int *graph = new int[n * n];
	Metrix c = (int(*)[n])graph;

	for (int i = 0; i < n; ++ i)
	{
		for (int j = 0; j < n; ++ j)
		{
			c[i][j] = getSentinel();
			for (int k = 0; k < n; ++ k)
			{
				if (getSentinel() != left[i][k] && getSentinel() != right[k][j])
				{
					c[i][j] = std::min(c[i][j], left[i][k] + right[k][j]);
				}
			}
		}
	}

	return c;
}

在计算时，我们首先把结果矩阵里面的值均初始化为最大，然后再计算它和当前两个结点权重之间的最小值，返回的最小值就是两个顶点之间的最小权重。在这里，left[i][k]就是结点i->k的最短路径值，然后，right[k][j]就是k->j的最小权重值，把2个相加就是i->j的最小权重值。接着来看看矩阵乘法的算法：

Metrix squareMatrixMultiply(Metrix left, Metrix right)
{
	const int n = VERTEX_NUMBER;
	int *graph = new int[n * n];
	Metrix c = (int(*)[n])graph;

	for (int i = 0; i < n; ++ i)
	{
		for (int j = 0; j < n; ++ j)
		{
			c[i][j] = 0;
			for (int k = 0; k < n; ++ k)
			{
				c[i][j] += left[i][k] * right[k][j];
			}
		}
	}

	return c;
}

是不是和上面的算法很相似呢。这里计算c[i][j]的值就是left矩阵的第i行的值乘以right的第j列的所有值的结果的总和。

然后，计算最短路径有2种方法，慢速的和快速的，其中快速的是在慢速的基础上做优化。先来看看慢速的如何计算：

Metrix slowAllPairsShortestPaths(Metrix graph)
{
	const int n = VERTEX_NUMBER;
	int *tmp = new int[n * n];
	Metrix c = (int(*)[n])tmp;
	memcpy(c, graph, n * n * sizeof(4));

	for (int m = 1; m < n - 1; ++ m)
	{
		Metrix p = entendShortestPaths(c, graph);
		delete [] c;
		c = p;
		printfMatrix(c);
	}

	return c;
}

我们在每次扩展最短路径的结果中，把返回的结果矩阵继续和原始矩阵做扩展，直到计算n-1次为止。而在这个算法上做的优化则是：因为我们的目的只是需要得出n-1次的最后结果，而不关心中间结果。所以我们可以每次进行m*2操作来让m的值进行递增，而不是m+1。

Metrix fasterAllPairsShortestPaths(Metrix graph)
{
	const int n = VERTEX_NUMBER;
	int *tmp = new int[n * n];
	Metrix c = (int(*)[n])tmp;
	memcpy(c, graph, n * n * sizeof(4));

	int m = 1;
	while (m < n - 1)
	{
		Metrix p = entendShortestPaths(c, c);
		delete [] c;
		c = p;
		printfMatrix(c);
		m *= 2;
	}

	return c;
}

我们可以来看看最短路径的图解过程：

慢速最短路径图解过程

而我们再来测试下慢速和快速的运行结果，也使用上图中一样的图：

int _tmain(int argc, _TCHAR* argv[])
{
	copyright();
	cout << getSentinel() << endl;

	cout << "directed adjacency matrix: " << endl;
	int graphmetrix[VERTEX_NUMBER][VERTEX_NUMBER] = 
	{
		{0, 3, 8, 0x7fffffff, -4},
		{0x7fffffff, 0, 0x7fffffff, 1, 7},
		{0x7fffffff, 4, 0, 0x7fffffff, 0x7fffffff},
		{2, 0x7fffffff, -5, 0, 0x7fffffff},
		{0x7fffffff, 0x7fffffff, 0x7fffffff, 6, 0},
	};
	cout << "directed weight graph structure: " << endl;
	for (int x = 0; x < VERTEX_NUMBER; ++ x)
	{
		cout << "vertex " << x + 1 << "；";
		for (int y = 0; y < VERTEX_NUMBER; ++ y)
		{
			if (0 != graphmetrix[x][y])
			{
				cout << y + 1 << " ";
			}
		}
		cout << endl;
	}
	cout << "origin: " << endl;
	printfMatrix(graphmetrix);
	cout << "slow algorithm: " << endl;
	Metrix c = slowAllPairsShortestPaths(graphmetrix);
	delete [] c;
	cout << "faster algorithm: " << endl;
	c = fasterAllPairsShortestPaths(graphmetrix);
	delete [] c;

	return 0;
}