图论——最短路

1、floyed

使用邻接矩阵，三重循环枚举所有边，然后做三角形迭代。时间复杂度为O(n^2).太简单就不给代码了。

2、迪杰斯特拉（英文打不来）

迪杰斯特拉其实是贪心算法，每次都选取距离最近的点，进行三角形迭代，从而保证所得路径最短。迪杰斯特拉是求单源点到其他所有点的最短路。需要注意的是迪杰斯特拉不允许出现负权。时间复杂度为O（n^2）.

代码如下：

	memset(dis,10,sizeof(dis));
	memset(flag,false,sizeof(flag));
	for(int i=1;i<=t;i++)dis[i]=a[i][ts];
	dis[ts]=0;
	flag[ts]=true;
	for(int i=1;i<=t;i++)
	{
		int minn=1000000000,k=0;
		for(int j=1;j<=t;j++)
		{
			if(dis[j]<minn&&!flag[j])
			{
				minn=dis[j];
				k=j;
			}
		}
		if(k==0)break;
		flag[k]=true;
		for(int j=1;j<=t;j++)
		{
			if(dis[k]+a[k][j]<dis[j]&&!flag[j])
			{
				dis[j]=dis[k]+a[k][j];
			}
		}
	}

3、bellman-ford

之前的迪杰斯特拉是基于点的迭代，bellman-ford则是基于边的迭代。每次都列举所有边进行三角形迭代，时间复杂度为O(n*m)。注意bellman-ford可以用来判断负权回路。

代码如下：

void bell(int st)
{
	memset(d,10,sizeof(d));
	d[st]=0;
	for(int k=1;k<=t;k++)
	{
		bool flag=false;
		for(int j=1;j<=t;j++)
		{
			if(d[a[j].st]+a[j].v<d[a[j].en])
			{
				d[a[j].en]=d[a[j].st]+a[j].v;
				flag=true;
			}
		}
		if(!flag)return;
	}
}