Til the Cows Come Home(POJ 2387)

Til the Cows Come Home(POJ 2387)
Time Limit: 1000MS Memory Limit: 65536K
Total Submissions: 51512 Accepted: 17411
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.
Source

USACO 2004 November

题意：就是求给出的路径中，从n到1的最短路（双向图）。

#include <stdio.h>
#include <string.h>
#include <algorithm>
#define NUM 1005
#define maxint (1<<29)

using namespace std;

int c[NUM][NUM];
int dist[NUM];
int pre[NUM];


///Dijkstra
///顶点个数n,源点v
///数组dist保存从源点v到每个顶点的最短特殊路径长度
///数组prev保存每个顶点在最短路径上的前一个节点
void dijkstra (int n,int v,int dist[],int prev[],int c[][NUM])
{
    int i,j;
    bool s[NUM];
    ///初始化数组
    for(i=1; i<=n; i++)
    {
        dist[i] = c[v][i];
        s[i]=false;
        if(dist[i]>maxint) prev[i]=0;
        else prev[i] = v;
    }

    ///初始化源节点
    dist[v] = 0;
    s[v] = true;
    for(i=1; i<n; i++)   ///其余节点
    {
        /// 在数组dist中寻找未处理节点的最小值
        int tmp = maxint;
        int u = v;
        for(j=1; j<=n; j++)
        {
            if(!s[j]&&(dist[j]<tmp))
            {
                u=j;
                tmp=dist[j];
            }
        }

        s[u] = true;    ///节点u加入s中
        ///利用节点u更新数组dist
        for(j=1; j<=n; j++)
        {
            if(!s[j]&&c[u][j]<maxint)
            {
                ///newdist为从源节点到该点的最短特殊路径
                int newdist = dist[u] + c[u][j];
                if(newdist<dist[j])
                {
                    ///修改最短路径
                    dist[j]=newdist;
                    ///修改j的前一个节点
                    prev[j]=u;
                }
            }
        }
    }
}


///根据数组pre计算单源最短路径的算法
/*
void traceback (int v,int i,int prev[])
{
    printf("%d<--",i);
    i=prev[i];
    if(i!=v) traceback(v,i,prev);
    if(i==v) printf("%d",i);
}
*/

///根据数组pre计算源点v到所有其他顶点最短路径的迭代算法
/*
for(int j=2;j<=n;j++)
{
    printf("%d",j);
    int t=pre[j];
    while(t!=1)
    {
        printf("<--%d",t);
        t=pre[t];
    }
    printf("<--1\n");
}
*/

int main()
{
    int n,v;
    for(int i=0; i<NUM; i++)
    {
        for(int j=0; j<NUM; j++)
            c[i][j] = maxint + 1 ;
    }
    scanf("%d%d",&v,&n);
    for(int i=1; i<=v; i++)
    {
        int father,son,val;
        scanf("%d%d%d",&father,&son,&val);
        c[father][son]=c[son][father]=min(c[son][father],val);
    }
    dijkstra(n,n,dist,pre,c);
    printf("%d\n",dist[1]);
    return 0;
}

    dij的过程无非是给出一个源点，然后找一个到该源点最近的点（第一次找的肯定是与它邻接的边权最小的点），然后以此点为基础，对其它点进行松弛，修改它们到源点的当前最短距离，迭代N-1次后，每个点到源点的最短距离便随之确定。

    

#include <stdio.h>
#include <string.h>
#define MAXN 1005
#define INF 1000000
int map[MAXN][MAXN];
bool vis[MAXN];
int d[MAXN];
int N;
void dijkstra(int s,int n)
{
 int i,j;
 for (i=1; i<=n; i++)
  d[i] = map[s][i];
 vis[s] = 1;
 for (i=1; i<=n-1; i++)
 {
  int now,min = INF;
  for (j=1; j<=n; j++)
  {
   if (!vis[j] && d[j]<min)
   {
    min = d[j];
    now = j;
   }
  }
  vis[now] = 1;

  //Relax
  for (j=1; j<=n; j++)
   if ( !vis[j] && d[now]+map[now][j]<d[j])
    d[j] = d[now]+map[now][j];
 }
}

int main()
{
 int T,N,i,x,y,len;
 scanf("%d%d",&T,&N);
 memset(vis,0,sizeof(vis));
 memset(map,INF,sizeof(map));
 for (i=1; i<=T; i++)
 {
  scanf("%d%d%d",&x,&y,&len);
  if (len<map[x][y])
  {
   map[x][y] = len;
   map[y][x] = len;
  }
 }
 dijkstra(N,N);
 printf("%d\n",d[1]);
 return 0;
}