对dijkstra的浅见（引例 poj 2457）

The cows have been sent on a mission through space to acquire a new milking machine for their barn. They are flying through a cluster of stars containing N (1 <= N <= 50,000) planets, each with a trading post.

The cows have determined which of K (1 <= K <= 1,000) types of objects (numbered 1..K) each planet in the cluster desires, and which products they have to trade. No planet has developed currency, so they work under the barter system: all trades consist of each party trading exactly one object (presumably of different types).

The cows start from Earth with a canister of high quality hay (item 1), and they desire a new milking machine (item K). Help them find the best way to make a series of trades at the planets in the cluster to get item K. If this task is impossible, output -1.

* Line 1: Two space-separated integers, N and K.

* Lines 2..N+1: Line i+1 contains two space-separated integers, a_i and b_i respectively, that are planet i‘s trading trading products. The planet will give item b_i in order to receive item a_i.

* Line 1: One more than the minimum number of trades to get the milking machine which is item K (or -1 if the cows cannot obtain item K).

* Lines 2..T+1: The ordered list of the objects that the cows possess in the sequence of trades.

6 5
1 3
3 2
2 3
3 1
2 5
5 4

4
1
3
2
5

OUTPUT DETAILS:

The cows possess 4 objects in total: first they trade object 1 for object 3, then object 3 for object 2, then object 2 for object 5.

题意：物品交换：n个交换方式，k是目标物品，用物品1 换k，求最少交换的次数。

思路：建图 map[u][v]=1,权值为 1，表示一次交换，即每条路都是一种交换方式，由题是单向图。

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define INF 0x3f3f3f3f
#define maxn 1000+10
using namespace std;
int map[maxn][maxn];
int dis[maxn];
int pre[maxn];
int kind;

void dijkstra(int s)
{
    int vis[maxn],minn,pos;
    memset(vis,0,sizeof vis);
    for(int i=0;i<kind+1;i++)
        dis[i]=INF;
    dis[s]=0;
    for(int i=0;i<kind;i++)
    {
        minn=INF;
        for(int j=1;j<=kind;j++)
            if(!vis[j]&&minn>dis[j])
            {
                minn=dis[j];
                pos=j;
            }
        vis[pos]=1;
        for(int j=1;j<=kind;j++)
            if(!vis[j]&&dis[j]>dis[pos]+map[pos][j])
            {
                pre[j]=pos;
                dis[j]=dis[pos]+map[pos][j];                   //每更新一遍dis ，刷新一遍 pre
            }

    }
}

void print_path(int aim)  //路径输出函数
{

    int n=dis[aim];          // dis是多少，就交换了多少次，有多少个前驱。
    int path[maxn];          //倒着记录路径
    int step=0,temp;
    path[++step]=aim;
    temp=aim;
    printf("%d\n",n+1);
    for(int i=0;i<n;i++)
    {
        temp=pre[temp];
        path[++step]=temp;
    }
 
    for(int i=step;i>=1;i--)  //倒着输出
        printf("%d\n",path[i]);
}



int main()
{
    int n,k;
    while(scanf("%d%d",&n,&k)!=EOF)
    {
        int u,v;
        kind=-1;
        for(int i=0;i<maxn;i++)
            for(int j=0;j<maxn;j++)
                map[i][j]=INF;
        for(int i=0;i<n;i++)
        {
            scanf("%d%d",&u,&v);
            map[u][v]=1;
            if(kind<max(u,v))
                kind=max(u,v);
        }
        dijkstra(1);
        if(dis[k]<INF)
            print_path(k);
        else
            printf("-1\n");

    }

    return 0;
}

当然了，这一题还涉及了一个对最短路径的输出问题。

如何输出呢？

设置一个pre [ i ]=pos 数组，记录点 i 的前驱点 pos

为何要设置前驱点呢？

    因为dijkstra更新dis【】的时候是根据 pos点更新的，所以每更新一次，就要刷新一遍pre[ ]数组;

    即：仅仅只有松弛操作，会对点 v 的前驱点进行改变，所以每进行一遍松弛操作，就要更新前驱结点。