模板---最短路径

Floyed算法：：

//O(n^3)
const int N = 100;
int nn[N][N];
void floyed(int n)
{
	int k,i,j;
	for(k=1;k<=n;k++)
	{
		for(i=1;i<=n;i++)
		{
			if(i != k)
			{
				for(j=1;j<=n;j++)
				{
					if(i!=j && j!=k && nn[i][j]>nn[i][k]+nn[k][j])
						nn[i][j] = nn[i][k]+nn[k][j];
				}
			}
		}
	}
}

Dijkstra算法：：

//O(n^2)
//可堆优化与临阶表优化
const int INF = 0x3f3f3f3f;
const int N = 105;
int nn[N][N];
int dis[N];		//距离 
int pre[N]=0;	//路径 
void dijkstra(int h)
{
	memset(dis,0x3f,sizeof(dis));
	int i,j;
	bool bj[N] = {0};
	for(i=1;i<=N;i++)
	{
		dis[i] = nn[h][i];
		if(dis[i] < INF)
			pre[i] = h;
	}
	dis[h] = 0;
	bj[h] = 1;
	for(i=2;i<=N;i++)
	{
		int mi = INF;
		int no;
		for(j=1;j<=N;j++)
		{
			if(!bj[j] && dis[j]<mi)
			{
				no = j;
				mi = dis[j];
			}
		}
		bj[no] = 1;
		for(j=1;j<=N;j++)
		{
			if(!bj[j] && nn[no][j]<INF && dis[no]+nn[no][j]<dis[j])
			{
				dis[j] = dis[no]+nn[no][j];
				pre[j] = no;
			}
		}
	}
}

Bellman-Ford算法：：

//O(ne)
const int INF = 0x3f3f3f3f;
const int N = 105;
int dis[N];
struct edge{
	int u,v;
	int l;		//cost
	edge(int _u=0,int _v=0,int _l=0):n(_u),v(_v),l(_l) {};
};
vector<edge> es;
bool bellman_ford(int h)
{
	int i,j;
	memset(dis,0x3f,sizeof(dis));
	dis[h] = 0;
	for(i=1;i<N;i++)
	{
		bool bj=0;
		for(j=0;j<es.size();j++)
		{
			int u,v,l;
			u = es[j].u;
			v = es[j].v;
			l = es[j].l;
			if(dis[v] > dis[u]+l)
			{
				dis[v] = dis[u]+l;
				bj = 1;
			}
		}
		if(!bj)
			return 1;
	}
	for(i=0;i<es.size();i++)
	{
		if(dis[es[j].v] > dis[es[j].u]+es[j].l)
			return 0;
	}
	return 1;
}

SPFA 算法：：

//O(KE) K是常数 
const int INF = 0x3f3f3f3f;
const int N=1010;
struct node{
	int v,w;
	node(int _v=0,int _w=0) : v(_v),w(_w) {}
};
vector<node> nn[N];
int dis[N],vis[N];
void SPFA(int u,int v)
{
	queue<int> qu;
	memset(dis,0x3f,sizeof(dis));
	memset(vis,0,sizeof(vis));
	qu.push(u);
	dis[u] = 0;
	vis[u] = 1;
	while(!qu.empty())
	{
		int no = qu.front();
		qu.pop();
		vis[no] = 0;
		for(i=0;i<nn[no].size();i++)
		{
			if(dis[no]+nn[no][i].w < dis[nn[no][i].v])
			{
				dis[nn[no][i].v] = dis[no]+nn[no][i].w;
				if(vis[nn[no][i].v] == 0)
				{
					qu.push(nn[no][i].v);
					vis[nn[no][i].v] = 1;
				}
			}
		}
	}
}