HDU 2066 迪杰斯特拉算法 单源最短路径 + 优先队列优化

题意

大意：

与草儿家相连的城市，路径长度为0.

求草儿想去的地方的单元最短路径，取最小值。

Problem Description

虽然草儿是个路痴（就是在杭电待了一年多，居然还会在校园里迷路的人，汗~),但是草儿仍然很喜欢旅行，因为在旅途中 会遇见很多人（白马王子，^0^），很多事，还能丰富自己的阅历，还可以看美丽的风景……草儿想去很多地方，她想要去东京铁塔看夜景，去威尼斯看电影，去阳明山上看海芋，去纽约纯粹看雪景，去巴黎喝咖啡写信，去北京探望孟姜女……眼看寒假就快到了，这么一大段时间，可不能浪费啊，一定要给自己好好的放个假，可是也不能荒废了训练啊，所以草儿决定在要在最短的时间去一个自己想去的地方！因为草儿的家在一个小镇上，没有火车经过，所以她只能去邻近的城市坐火车（好可怜啊~）。

Input

输入数据有多组，每组的第一行是三个整数T，S和D，表示有T条路，和草儿家相邻的城市的有S个，草儿想去的地方有D个；
接着有T行，每行有三个整数a，b，time,表示a,b城市之间的车程是time小时；(1=<(a,b)<=1000;a,b 之间可能有多条路)
接着的第T+1行有S个数，表示和草儿家相连的城市；
接着的第T+2行有D个数，表示草儿想去地方。

Output

输出草儿能去某个喜欢的城市的最短时间。

分析

将0点作为草儿的家。

仅需要一次迪杰斯特拉，即不需要在   当前节点== 终点  的时候break

注意题目可能会有重边，输入的边长需要判断是不是最短

核心算法中的for循环的次数，是城市的数量。城市的数量随输入的节点更新。（注意不是连续的节点）

核心算法中的，mini标记当前求得的最短路径对应的城市编号。初始化为0，千万不能初始化成-1

提问：为什么这题不能初始化为-1？是因为没有break吗？

代码

#include<iostream>
#include<sstream>
#include<algorithm>
#include<string.h>
#include<stack>
#include<queue>
#include<set>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 1005;
int mp[maxn][maxn];
int dis[maxn];
int vis[maxn];
int want[maxn];
int pre[maxn];
int t , s , d;
int citynum;

void Dij()
{
    memset(vis , 0 , sizeof(vis));
    for(int i = 0 ; i <= citynum ;i++)
    {
            if(mp[0][i] != inf)
                dis[i] = mp[0][i];
            else
                dis[i] = inf;
    }
    vis[0] = 1;


    for(int i = 1 ; i <= citynum - 1 ;i++)
    {
            int mini = 0;// 初始化成-1 ，WA一天
            int mind = inf;
            for(int j = 1; j <= citynum ; j++)
            {
                if(vis[j] == 0 && dis[j] < mind)
                {
                    mini = j;
                    mind = dis[j];
                }
            }
            vis[mini] = 1;
            for(int j = 1; j <= citynum ; j++)
            {
                if(vis[j] == 0 && dis[j] > dis[mini] + mp[mini][j])
                {
                    dis[j] = dis[mini] + mp[mini][j];
                    pre[j] = mini;
                }
            }
    }
}


int main()
{
    while( scanf("%d%d%d", &t ,&s , &d)!=EOF)
    {
        citynum = 0;

        for(int i = 0 ; i < maxn ;i++)
        {
            for(int j = 0; j < maxn ;j++)
            {
              //  mp[i][j] = inf;
              if(i == j)mp[i][j] = 0;
              else mp[i][j] = inf;
            }
        }

        for(int i = 0; i < t ; i++)
        {
            int a , b ,time;
            cin >> a >> b >> time;
            if(time < mp[a][b] || time < mp[b][a])
                mp[a][b] = mp[b][a] = time;
           // mp[a][b] = mp[b][a] = min(mp[a][b] , time);
            citynum = max( citynum , max( a , b));
        }
        for(int i = 0 ; i < s; i++)
        {
            int lian ;
            cin >> lian;
          //  citynum = max(citynum , lian);
            mp[0][lian] = mp[lian][0] = 0;
        }
        for(int i = 0 ; i < d ; i++)
            cin >> want[i];

        Dij();

        int ans = inf;
        for(int i= 0; i < d ;i ++)
        {
            ans = min( ans , dis[want[i]]);
        }
        cout << ans << endl;
    }
    return 0;
}

优先队列优化

话说使用优先队列后，是不是不用考虑重边的情况？因为按照结构体的排序规则， 时间长的排在了后面。

优先队列的自定义排序：优先队列自定义排序使用方法详解

struct Node
{
    int x , d;
    Node() {}
    Node(int a , int b) { x = a ; d = b ;}
    friend bool operator < (Node a , Node b)
    {
        if( a.d == b.d ) return a.x < b.x;
        else return a.d > b.d;
    }

};

以该段为例。首先明确优先队列，首先出队列的是优先级大的元素

重载小于号

不考虑距离相等的情况，如果a的距离比b的距离大，那么a的优先级小于b的优先级 , 则b先出列

也就是说，距离小的先出列

 

或者使用另外一种排序方式：

struct Node
{
    int x , d;
    Node() {}
    Node(int a , int b) { x = a ; d = b ;}

    bool operator < (const Node & a) const
    {
        if( d == a.d ) return x < a.x;
        else return d > a.d; //如果d > a.d 则优先级 cur < a ， a优先级大， a先出列
    }
};

在优化的代码中，vector<Node> eg[maxn]; 来存储边，也就会邻接表的方式。

eg[ i ]表示与第 i 个节点连接的节点数组。

Node 中x 表示节点编号，d表示距离。

#include<iostream>
#include<sstream>
#include<algorithm>
#include<string.h>
#include<stack>
#include<queue>
#include<set>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 1005;

int t , s , d;
int citynum = 0;
struct Node
{
    int x , d;
    Node() {}
    Node(int a , int b) { x = a ; d = b ;}
//    friend bool operator < (Node a , Node b)
//    {
//        if( a.d == b.d ) return a.x < b.x;
//        else return a.d > b.d;
//    }
    bool operator < (const Node & a) const
    {
        if( d == a.d ) return x < a.x;
        else return d > a.d; //如果d > a.d 则优先级 cur < a ， a优先级大， a先出列
    }
};
vector<Node> eg[maxn];
int dis[maxn];
int want[maxn];

void Dij(int start)
{
    for(int i = 0 ; i < maxn ;i++)
        dis[i] = inf;
    dis[start] = 0;

    priority_queue<Node> Q;
    Q.push(Node(start , dis[start]));
    while(!Q.empty())
    {
       Node x = Q.top();
       Q.pop();
       for(int i = 0 ;  i < eg[x.x].size(); i++)
       {
           Node y = eg[x.x][i];
           if(dis[y.x] > x.d + y.d)
           {
               dis[y.x] = x.d + y.d;
               Q.push(Node(y.x , dis[y.x]));
           }
       }
    }

}

int main()
{
    while(scanf("%d%d%d" , &t , &s , &d) != EOF)
    {
        citynum = 0;
        for(int i = 0 ;i < maxn ;i++)
            eg[i].clear();
        memset(want , 0 ,sizeof(want));
        for(int i = 0 ; i < t; i++)
        {
            int a  , b , time;
            cin >> a >> b >> time;
            citynum = max(citynum , max( a , b));
            eg[a].push_back(Node(b , time));
            eg[b].push_back(Node(a , time));
        }
        for(int i = 0 ; i < s; i++)
        {
            int lian;
            cin >> lian;
            eg[0].push_back(Node(lian , 0));
        }
        for(int i = 0; i < d; i ++)
            cin >> want[i];

        Dij(0);
        int ans = inf;
        for(int i = 0 ;i < d  ;i++)
        {
            ans = min(ans , dis[want[i]]);
        }
        cout << ans << endl;
    }
}