# poj2387——Til the Cows Come Home【最短路】

Til the Cows Come Home
 Time Limit: 1000MS Memory Limit: 65536K Total Submissions: 66783 Accepted: 22454

Description

Bessie is out in the field and wants to get back to the barn to get as much sleep as possible before Farmer John wakes her for the morning milking. Bessie needs her beauty sleep, so she wants to get back as quickly as possible.

Farmer John's field has N (2 <= N <= 1000) landmarks in it, uniquely numbered 1..N. Landmark 1 is the barn; the apple tree grove in which Bessie stands all day is landmark N. Cows travel in the field using T (1 <= T <= 2000) bidirectional cow-trails of various lengths between the landmarks. Bessie is not confident of her navigation ability, so she always stays on a trail from its start to its end once she starts it.

Given the trails between the landmarks, determine the minimum distance Bessie must walk to get back to the barn. It is guaranteed that some such route exists.

Input

* Line 1: Two integers: T and N

* Lines 2..T+1: Each line describes a trail as three space-separated integers. The first two integers are the landmarks between which the trail travels. The third integer is the length of the trail, range 1..100.

Output

* Line 1: A single integer, the minimum distance that Bessie must travel to get from landmark N to landmark 1.

Sample Input

5 5
1 2 20
2 3 30
3 4 20
4 5 20
1 5 100

Sample Output

90

Hint

INPUT DETAILS:

There are five landmarks.

OUTPUT DETAILS:

Bessie can get home by following trails 4, 3, 2, and 1.

bellman_ford算法

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<iostream>
#include<cmath>
#define MAXN 200010
#define INF 0x3f3f3f3f
using namespace std;
struct node{
int to,next,cost;
}edge[MAXN];
int dis[MAXN];
int t,n;//t是边数，n是顶点数
//求解从顶点s出发到所有点的最短距离
void bellman_ford(int t,int n){
//int dis[MAXN];
memset(dis,INF,sizeof(dis));
dis[1]=0;
int check;
for(int k=1;k<=n;k++){
check=0;
for(int i=1;i<=t;i++){
if(dis[edge[i].to]>dis[edge[i].next]+edge[i].cost){
dis[edge[i].to]=dis[edge[i].next]+edge[i].cost;
check=1;
}
if(dis[edge[i].next]>dis[edge[i].to]+edge[i].cost){
dis[edge[i].next]=dis[edge[i].to]+edge[i].cost;
check=1;
}
}
if(check==0) break;
}
//printf("%d\n",dis[n]);
}
//检查负权回路
bool find_negative_loop(){
//memset(dis,0,sizeof(dis));
bool flag=false;
for(int i=1;i<=t;i++){
node e=edge[i];
if(dis[e.to]>dis[e.next]+e.cost){
flag=true;//说明存在负权回路
}
}
if(flag) return true;
return false;
}
int main(){
while(~scanf("%d%d",&t,&n)){
//memset(dis,INF,sizeof(dis));
for(int i=1;i<=t;i++){
scanf("%d%d%d",&edge[i].to,&edge[i].next,&edge[i].cost);
}
bellman_ford(t,n);
if(!find_negative_loop())
printf("%d\n",dis[n]);
}
return 0;
}
dijkstra写法：
#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
#include<vector>
#define MAXN 1010
#define INF 0xfffffff
using namespace std;
typedef struct node{
int to,cost;
node(int a,int b){
to=a;
cost=b;
};
bool friend operator <(node a,node b){
if(a.cost!=b.cost) return a.cost>b.cost;
return a.to>b.to;
}
};
vector<node> G[MAXN];
int dis[MAXN],n,t;
void dijkstra(int s){
fill(dis,dis+n+1,INF);
dis[s]=0;
priority_queue<node> que;
que.push(node(s,dis[s]));//原点入队
while(!que.empty()){
node f=que.top();que.pop();
for(int i=0;i<G[f.to].size();i++){
node t=G[f.to][i];
if(dis[t.to]>t.cost+f.cost){
dis[t.to]=t.cost+f.cost;
que.push(node(t.to,dis[t.to]));
}
}
}
}
int main(){
int p,q,w;
while(~scanf("%d%d",&t,&n)){
for(int i=0;i<=n;i++) G[i].clear();
while(t--){
scanf("%d%d%d",&p,&q,&w);
G[p].push_back(node(q,w));
G[q].push_back(node(p,w));
}
dijkstra(1);
printf("%d\n",dis[n]);
}
return 0;
}
spfa写法：
#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#define MAXN 200010
#define INF  0x3f3f3f3f
using namespace std;
int n,t;
int top;
struct node{
int to,next,cost;
}edge[MAXN];
//建立领接表
edge[top].to=v;
edge[top].cost=cot;
}
void spfa(int x){
queue<int> que;
dis[x]=0;
que.push(x);
while(!que.empty()){
int ant=que.front();
que.pop();
for(int i=u;i!=-1;i=edge[i].next){
if(dis[edge[i].to]>dis[ant]+edge[i].cost){
dis[edge[i].to]=dis[ant]+edge[i].cost;
que.push(edge[i].to);
}
}
}
}
int main(){
while(~scanf("%d%d",&t,&n)){
int t1,t2,cos;
top=0;
memset(dis,INF,sizeof(dis));
for(int i=1;i<=t;i++){
scanf("%d%d%d",&t1,&t2,&cos);
}