C Dijkstra + peso de nodo + peso de borde + número de borde estadístico + número de ruta estadística más corta + ruta guardada 1087 Todos los caminos conducen a Roma (30 puntos)

1087 Todos los caminos llevan a Roma (30 分)

De hecho, hay muchas rutas turísticas diferentes desde nuestra ciudad a Roma. Se supone que debe encontrar a sus clientes la ruta con el menor costo mientras obtiene la mayor felicidad.

Especificación de entrada:
cada archivo de entrada contiene un caso de prueba. Para cada caso, la primera línea contiene 2 enteros positivos N (2≤N≤200), el número de ciudades, y K, el número total de rutas entre pares de ciudades; seguido por el nombre de la ciudad inicial. Las siguientes líneas N − 1 dan el nombre de una ciudad y un número entero que representa la felicidad que uno puede obtener de esa ciudad, excepto la ciudad inicial. Luego siguen las líneas K, cada una describe una ruta entre dos ciudades en el formato City1 City2 Cost. Aquí el nombre de una ciudad es una cadena de 3 letras mayúsculas en inglés, y el destino siempre es ROM, que representa Roma.

Especificación de salida:
para cada caso de prueba, se supone que debemos encontrar la ruta con el menor costo. Si tal ruta no es única, se recomendará la que tenga la máxima felicidad. Si dicha ruta aún no es única, entonces generamos la que tiene la felicidad promedio máxima: el juez garantiza que dicha solución existe y es única.

Por lo tanto, en la primera línea de salida, debe imprimir 4 números: el número de rutas diferentes con el menor costo, el costo, la felicidad y la felicidad promedio (tome solo la parte entera) de la ruta recomendada. Luego, en la siguiente línea, se supone que debe imprimir la ruta en el formato Ciudad1-> Ciudad2-> ... -> ROM.

Entrada de muestra:

6 7 HZH
ROM 100
PKN 40
GDN 55
PRS 95
BLN 80
ROM GDN 1
BLN ROM 1
HZH PKN 1
PRS ROM 2
BLN HZH 2
PKN GDN 1
HZH PRS 1

Salida de muestra:

3 3 195 97
HZH->PRS->ROM

Ponderación de nodos de título : felicidad de cada ciudad
Pesos de borde: costo de cada ruta
Cuenta bordes: cuenta el número de nodos pasados ​​por la
ruta más corta rutas más cortas: cuenta la cantidad de rutas más cortas rutas
guardadas: guardar Ruta, salida posterior

Cada uno de los anteriores necesita mantener una lista;

int D[MAXcity];        //最少花费
int mostHap[MAXcity];  //最多快乐度
int Count[MAXcity];   //最短路径的个数 
int C[MAXcity];      //统计路程经过的边数 
int path[MAXcity];    //记录路径

Al menos los más cortos se inicializan a INFINITY; el
número de lados estadísticos se inicializa a 0;

Expande el algoritmo de Dijkstra:

void Dijkstra()
{
	bool visited[MAXcity];
	fill(D,D+MAXcity,INFINITY); //最短距离 
	fill(visited,visited+MAXcity,false);
	fill(mostHap,mostHap+MAXcity,0);
	fill(Count,Count+MAXcity,0);
	fill(C,C+MAXcity,0);
	
	D[0]=0;     //自己到自己花钱0
	Count[0]=1; //自己到自己有一条 
	path[0]=-1; //设置开头-1，方便后续入遍历输出
	//
	while(1)
	{	
		int Min=INFINITY;
		int V=-1;
		for(int i=0;i<N;i++)
			if(!visited[i]&&D[i]<Min)
			{
				Min=D[i];
				V=i;
			}
	 
	 if(V==-1) break;
	 visited[V]=true;
	 for(int i=0;i<N;i++)
	 {
	 	if(!visited[i]){
		
	 	if(D[V]+Graph[V][i]<D[i])
	 	{
	 		D[i]=D[V]+Graph[V][i];
	 		mostHap[i]=mostHap[V]+happiness[i];
	 		Count[i]=Count[V]; 
	 		C[i]=C[V]+1;
	 		path[i]=V;
		 }
		 else if(D[V]+Graph[V][i]==D[i]){       
		 //这里的else很关键——小于后D[i]改变，可能满足后序的== 
		 	Count[i]+=Count[V];
		 	if(mostHap[i]<mostHap[V]+happiness[i])
		 	{
		 		D[i]=D[V]+Graph[V][i];
	 			mostHap[i]=mostHap[V]+happiness[i];
	 			path[i]=V;
	 			C[i]=C[V]+1;
			 } 
		 }
	 }
	 } 
	}
}

Tenga en cuenta que
si el juicio es igual, debe agregar más si;
dado que la condición anterior menor que cambiará el valor de D [i], puede ingresar == juicio nuevamente; es
difícil
mantener cada lista;

要求数最短路径有多少条
 count[origin] = 1;
 如果找到更短路：count[i]=count[V]；因为W与V只差一条边，所以两者相同；
 如果找到等长路：count[i]+=count[V]；登场路的数量为W前面一个点的路的数量；

要求边数最少的最短路
 C[origin] = 0;
 如果找到更短路：C[i]=C[V]+1;
 如果找到等长路：C[i]=C[V]+1;

要求最短路径的快乐度最高
 mostHap[orrgin]=0;
 如果找到更短路：mostHap[i]=mostHap[V]+happiness[i]
 如果找到等长路：if(mostHap[V]+happiness[i]>mostHap[i])
mostHap[i]=mostHap[V]+happiness[i];

得到路径
 每个条件都加上 path[i]=V;
最后通过path[]可以一路找到出发点；

Método de entrada:
use el mapa, abra la matriz de nombres para guardar el nombre,
abra la matriz de felicidad para guardar la felicidad de cada ciudad;

void input()
{
	cin>>N>>K>>names[0];       //名称 
	happiness[0]=0;            //幸福感 
	for(int i =1;i<N;i++)
	{
		cin>>names[i]>>happiness[i];
		if(names[i]=="ROM") Rom=i;
	}
	for(int i=0;i<K;i++)
	{
		string a,b;
		int x,y,cost;
		cin>>a>>b>>cost;
		x=Findname(names,a);
		y=Findname(names,b);
		Graph[x][y]=cost;
		Graph[y][x]=cost;
	}
}

La función de búsqueda de nombre utilizada es un número de secuencia de búsqueda simple;
usar un mapa de tabla hash puede ser más conveniente de lograr, pero no lo uso;

int Findname(string names[],string name)
{
	for(int i=0;i<N;i++)
	{
		if(names[i]==name)
			return i;
	}
}

Archivo de encabezado y función principal

#include<iostream>
#include<cstring>
#include<algorithm>
#include<stack>
using namespace std;
#define INFINITY 65533
#define MAXcity 201

string names[MAXcity];
int happiness[MAXcity];
int Graph[MAXcity][MAXcity];       //记得初始化为正无穷 
int N,K;
string start;
int Rom;

int main()
{
	fill(Graph[0],Graph[0]+MAXcity*MAXcity,INFINITY);
	input();
	//得到图，名称，幸福感列表；
	//求0到各点的最少钱，并加上幸福感 
	//若最少钱相等，选幸福感最大的路线
	//若还相等——平均幸福感最大的——即幸福感除以路过的城市数 
	Dijkstra();
	cout<<Count[Rom]<<" "<<D[Rom]<<" "<<mostHap[Rom]<<" "<<mostHap[Rom]/C[Rom]<<endl;
	stack<int> P;
	int i=Rom;
	P.push(i);
	while(path[i]!=-1)
	{
		i=path[i];
		P.push(i);
	}
	
	while(!P.empty())
	{
		int t=P.top();
		P.pop();
		if(t!=Rom)
		cout<<names[t]<<"->";
		else cout<<names[t];
	}
}