Más corta (HDU 2544)

tema Enlace

título Descripción

En la competencia anual de la escuela, todos los finalistas estudiantes recibirán una camiseta agradable. Pero cada vez que nuestro personal de cientos de piezas de ropa enviado de vuelta al estadio de la tienda cuando están muy cansados! Así que ahora quieren encontrar la ruta más corta al estadio de la tienda, puede ayudar a ellos?

Formato de entrada

Que comprende una pluralidad de conjuntos de datos de entrada. La primera línea de cada dos enteros N, M (N <= 100 , M <= 10000), N representa unos intersecciones de calles Chengdu, el número de referencia 1 es para almacenar la ubicación de la intersección, la intersección designada N es la ubicación del estadio, M indica un par de opciones en Chengdu. N = M = 0 indica el final de la entrada. Siguiente M filas, cada fila comprende tres enteros A, B, C (1 < = A, B <= N, 1 <= C <= 1000), indica que hay un camino entre la intersección A y la intersección B, nos el personal necesita tiempo C minutos viajó este camino.
línea de entrada para asegurar la presencia de al menos una pista de almacenar.

Formato de salida

Para cada línea de entrada y salida, que representa a los trabajadores de la pista vienen desde el momento tienda mínimo

Ejemplo de entrada

2 1
1 2 3
3 3
1 2 5
2 3 5
3 1 2
0 0

Ejemplo de salida

3
2

análisis

Simple de una sola fuente de plantilla problema del camino más corto, se utilizaron los siguientes Dijkstra algoritmo, algoritmo SLF SPFA de algoritmos de optimización y SPFA

fuente

el algoritmo de Dijkstra

#include <bits/stdc++.h>
#define MAXN 10005
using namespace std;
struct Edge{
	int v,w,next;
	Edge(){};
	Edge(int _v,int _w,int _next){
		v=_v,w=_w,next=_next;	
	};
	bool operator <(const Edge a)const{
		return w>a.w;
	}
}edge[MAXN*2];
int EdgeCount,head[MAXN];
int n,m,dis[MAXN];
bool used[MAXN];
void addEdge(int u,int v,int w)
{
	edge[++EdgeCount]=Edge(v,w,head[u]);
	head[u]=EdgeCount;
}
void dijkstra()
{
	priority_queue<Edge> q;
	memset(dis,0x3f,sizeof(dis));
	memset(used,false,sizeof(used));
	dis[1]=0;
	q.push(Edge{1,0,0});
	while(!q.empty()){
		int u=q.top().v;
		q.pop();
		if(used[u])continue;
		used[u]=true;
		for(int i=head[u];i;i=edge[i].next){
			int v=edge[i].v,w=edge[i].w;
			if(dis[v]>dis[u]+w){
				dis[v]=dis[u]+w;
				q.push(Edge{v,dis[v],0});
			}
		}
	}
	return ;
}
int main()
{
	while(1){
		scanf("%d%d",&n,&m);
		if(n==0&&m==0)break;
		memset(head,0,sizeof(head));
		EdgeCount=0;
		for(int i=1;i<=m;i++){
			int u,v,w;
			scanf("%d%d%d",&u,&v,&w);
			addEdge(u,v,w);
			addEdge(v,u,w);
		}
		dijkstra();
		printf("%d\n",dis[n]);
	}
	return 0;
}

algoritmo SPFA

#include <bits/stdc++.h>
#define MAXN 10005
using namespace std;
struct Edge{
	int v,w,next;
	Edge(){};
	Edge(int _v,int _w,int _next){
		v=_v,w=_w,next=_next;
	};
}edge[MAXN*2];
int EdgeCount,head[MAXN];
int n,m,dis[MAXN],ven[MAXN],nums[MAXN];
void addEdge(int u,int v,int w)
{
	edge[++EdgeCount]=Edge(v,w,head[u]);
	head[u]=EdgeCount;
}
void SPFA()
{
	queue<int> q;
	memset(dis,0x3f,sizeof(dis));
	memset(ven,0,sizeof(ven));
//	memset(nums,0,sizeof(nums));
	dis[1]=0;
	ven[1]=1;
//	nums[1]=1;
	q.push(1);
	while(!q.empty()){
		int u=q.front();q.pop();
		ven[u]=0;
		for(int i=head[u];i;i=edge[i].next){
			int v=edge[i].v,w=edge[i].w;
			if(dis[v]>dis[u]+w){
				dis[v]=dis[u]+w;
				if(!ven[v]){
					q.push(v);
					ven[v]=1;
//					nums[v]++;
//					if(nums[v]>n)return false;
				}
			}
		}
	}
//	return true;
}
int main()
{
	while(1){
		scanf("%d%d",&n,&m);
		if(!n&&!m)break;
		memset(head,0,sizeof(head));
		EdgeCount=0;
		for(int i=1;i<=m;i++){
			int u,v,w;
			scanf("%d%d%d",&u,&v,&w);
			addEdge(u,v,w);
			addEdge(v,u,w);
		}
		SPFA();
		printf("%d\n",dis[n]);
	}
	return 0;
}

Optimización de Algoritmos SPFA SLF

#include <bits/stdc++.h>
#define MAXN 10005
using namespace std;
struct Edge{
	int v,w,next;
	Edge(){};
	Edge(int _v,int _w,int _next){
		v=_v,w=_w,next=_next;
	};
}edge[MAXN*2];
int EdgeCount,head[MAXN];
int n,m,s,t,dis[MAXN],ven[MAXN],nums[MAXN];
void addEdge(int u,int v,int w)
{
	edge[++EdgeCount]=Edge(v,w,head[u]);
	head[u]=EdgeCount;
}
void SPFA()
{
	int cnt;
	deque<int> q;
	memset(dis,0x3f,sizeof(dis));
	memset(ven,0,sizeof(ven));
//	memset(nums,0,sizeof(nums));
	dis[1]=0;
	ven[1]=1;
//	nums[1]=1;
	q.push_back(1);
	while((cnt=q.size())){
		int u=q.front();q.pop_front();
		ven[u]=0;
		for(int i=head[u];i;i=edge[i].next){
			int v=edge[i].v,w=edge[i].w;
			if(dis[v]>dis[u]+w){
				dis[v]=dis[u]+w;
				if(!ven[v]){
					if(cnt>1&&dis[v]<dis[q.front()])q.push_front(v);
					else q.push_back(v);
					ven[v]=1;
//					nums[v]++;
//					if(nums[v]>n)return false;
				}
			}
		}
	}
//	return true;
}
int main()
{
	while(1){
		scanf("%d%d",&n,&m);
		if(!n&&!m)break;
		memset(head,0,sizeof(head));
		EdgeCount=0;
		for(int i=1;i<=m;i++){
			int u,v,w;
			scanf("%d%d%d",&u,&v,&w);
			addEdge(u,v,w);
			addEdge(v,u,w);
		}
		SPFA();
		printf("%d\n",dis[n]);
	}
	return 0;
}