Descripción
Una vaca de cada una de las N granjas (1 ≤ N ≤ 1000) convenientemente numerada 1… N asistirá a la gran fiesta de las vacas que se realizará en la granja #X (1 ≤ X ≤ N). Un total de M (1 ≤ M ≤ 100.000) unidireccionales (caminos de un solo sentido conectan pares de fincas; el camino i requiere Ti (1 ≤ Ti ≤ 100) unidades de tiempo para atravesarlo.
Cada vaca debe caminar hasta la fiesta y, cuando la fiesta termine, regresar a su granja. Cada vaca es perezosa y, por lo tanto, elige una ruta óptima con el menor tiempo. La ruta de regreso de una vaca puede ser diferente de su ruta original a la fiesta, ya que los caminos son de un solo sentido.
De todas las vacas, ¿cuál es la mayor cantidad de tiempo que una vaca debe pasar caminando de ida y vuelta a la fiesta?
———————————————— Línea de
entrada
1: Tres enteros separados por espacios, respectivamente: N, M y X
Líneas 2… M + 1: La línea i + 1 describe la carretera i con tres enteros separados por espacios: Ai, Bi y Ti. El camino descrito va desde la granja Ai hasta la granja Bi, requiriendo unidades de tiempo Ti para atravesarlo.
———————————————— Línea de
salida
1: Un entero: el tiempo máximo que una vaca debe caminar.
————————————————
Entrada de muestra
4 8 2
1 2 4
1 3 2
1 4 7
2 1 1
2 3 5
3 1 2
3 4 4
4 2 3
Salida de muestra
10
Ideas
Para cada vaca, Dijkstra puede obtener la ruta más corta desde el punto de inicio hasta el punto final. La ruta más corta devuelta solo debe invertirse entre el punto de inicio y el punto final, y finalmente generar el valor máximo de la ruta más corta registrada.
Parte del código
#include<queue>
#include<math.h>
#include<stdio.h>
#include<iostream>
using namespace std;
const int maxn=1e3+5;
typedef long long ll;
const int inf=0x3f3f3f3f;
const int minn=0xc0c0c0c0;
struct node
{
int v,w;
node(int v,int w):v(v),w(w){
}
};
struct Node
{
int v,w;
Node(int v,int w):v(v),w(w){
}
friend bool operator < (const Node a,const Node b)
{
return a.w > b.w;
}
};
vector<node> a[maxn];
priority_queue<Node> que;
bool vis[maxn];
int n;
int dis[maxn];
void dij(int s)
{
memset(dis,inf,sizeof(dis));
memset(vis,false,sizeof(vis));
dis[s]=0;
que.push(Node(s,0));
while(!que.empty())
{
int u=que.top().v;
que.pop();
vis[u]=true;
for(int i=0;i<a[u].size();i++)
{
int v=a[u][i].v;int w=a[u][i].w;
if(!vis[v]&&dis[v]>dis[u]+w)
{
dis[v]=dis[u]+w;
que.push(Node(v,dis[v]));
}
}
}
}
int main()
{
int m,x,u,v,w,ans;
ans=-1;
scanf("%d%d%d",&n,&m,&x);
for(int i=0;i<m;i++)
{
scanf("%d%d%d",&u,&v,&w);
u--;v--;
a[u].push_back(node(v,w));
}
for(int i=0;i<n;i++)
{
int sum=0;
dij(i);
sum+=dis[x-1];
dij(x-1);
sum+=dis[i];
ans=max(ans,sum);
}
printf("%d\n",ans);
return 0;
}