最短路 hdu 3499 Flight

最短路 hdu 3499 Flight

//最短路 hdu 3499 Flight



//最短路

//题意：给出n个地点,m条有向带权边,给出起点和终点,可以把

//其中一条边的权值减少一半,求起点到终点的最短路



//思路：分别求起点到各个点的最短路 和 终点到各个点的最短路(要用反向边)

//当然，把最短路存放在dis数组里,正向为dis1,方向为dis2

//然后循环每条边,求出每一边起点的dis1和每一边终点的dis2 还有该边的权值的一半 的和

//记录最小值就是答案了



//注意：

//1、如果是用优先队列优化dijsktra时,要记住放入队列里的不仅仅是点的下标,

//   还要有起点到该点的dis,然后根据dis从小到大排序

//2、优先队列重载的是 小于号'<' 而不是 大于号 '>'

//3、如果反向边是用另一个结构体数组保存则邻接表加边时只需++tot一次

//4、存储边的三个数组要都为500005而不是100005

//5、ios::sync_with_stdio(false); 记住有这句存在的情况下不要用stdio里的输入输出

//在没有这句的函数里好像可以



#include <stdio.h>

#include <cstring>

#include <string>

#include <queue>

#include <map>

#include <algorithm>

#include <iostream>



using namespace std;



#define comein freopen("in.txt", "r", stdin);

#define N 100005

#define M 500005

#define eps 1e-5



int tot;

int head[2][N]；

int start[M], end[M], price[M]; //存储边

__int64 dis1[N], dis2[N];

bool vis[N];



struct EDGE

{

    int to, next;

    int dis;

}edge[2][M];



//struct POINT

//{

//    int pos;

//    __int64 dis;

//    POINT(){}

//    POINT(int p, __int64 d)

//    {

//        this->pos = p;

//        this->dis = d;

//    }

//    bool operator < (const POINT &a)const

//    {

//        return this->dis > a.dis;

//    }

//};

//

//

//void dijsktra(int root, int st, __int64 *dis)

//{

//    memset(vis, false, sizeof(vis));  //优先队列优化

//    priority_queue<POINT> que;      //这里优先队列不仅要存下标，还要存dis，要不没按dis排序

//    dis[st] = 0;          //到某一点不一定是最短路，可能有多个点到达pos，然后把这些边排序下

//    int now = st;

//    while(1)

//    {

//        vis[now] = true;

//        for(int i = head[root][now]; i != -1; i = edge[root][i].next)

//        {

//            int to = edge[root][i].to;

//            if(vis[to] == false && (dis[to] == -1 || dis[to] > edge[root][i].dis + dis[now]))

//            {

//                dis[to] = dis[now] + edge[root][i].dis;

//                que.push(POINT(to, dis[to]));

//            }

//        }

//        int tmp_pos = now;

//        while(!que.empty())

//        {

//            POINT tmp = que.top();

//            que.pop();

//            if(vis[tmp.pos] == false)

//            {

//                now = tmp.pos;

//                break;

//            }

//        }

//        if(tmp_pos == now)

//            break;

//    }

//}



void add_edge(int from, int to, int d, int edgeCnt)

{

    edge[0][++tot].to = to;     //这里tot前要++,下面就不要了，因为这是二维的

    edge[0][tot].dis = d;

    edge[0][tot].next = head[0][from];

    head[0][from] = tot;



    edge[1][tot].to = from;         //建逆邻接表

    edge[1][tot].dis = d;

    edge[1][tot].next = head[1][to];

    head[1][to] = tot;



    start[edgeCnt] = from;      //存储边

    end[edgeCnt] = to;

    price[edgeCnt] = d;

}

void spfa(int root, int st, __int64 *dis) //root标记是求正向还是反向的

{

    memset(vis, false ,sizeof(vis));

    queue<int> que;



    que.push(st);

    vis[st] = true; //标志是否入队了

    dis[st] = 0;

    while(!que.empty())

    {

        int now = que.front();

        que.pop();

        for(int i = head[root][now]; i != -1; i = edge[root][i].next)

        {

            int to = edge[root][i].to;

            int d = edge[root][i].dis;

            if( dis[to] == -1 || dis[to] - d > dis[now])

            {

                dis[to] = d + dis[now];

                if(vis[to] == false )

                {

                    que.push(to);

                    vis[to] = true;

                }



            }

        }

        vis[now] = false;       //出队的点要重新标记为false

    }

}





int main()

{

    comein

    //后面不能用puts("-1"),为了找到这个错误,花了我一天多的时间

    ios::sync_with_stdio(false);//不过本来是用spfa的,以为这算法不行,就第一次用优先队列

    int n_city, n_flight;       //优化了dijsktra,发现推进队列的能仅仅是点的下标,还要有dis

    while(cin >> n_city >> n_flight)    //才能根据dis来排序

    {

        tot = 0;

        map<string, int> mp;

        memset(head, -1, sizeof(head));

        int cnt = 0, d;



        string from, to;

        for(int i = 0; i < n_flight; ++i)

        {

            cin >> from >> to >> d;

            if(mp[from] == 0) mp[from] = ++cnt;

            if(mp[to] == 0) mp[to] = ++cnt;



            add_edge(mp[from], mp[to], d, i);

        }

        cin >> from >> to;



        if(mp[from] == 0 || mp[to] == 0)

            cout << -1 << endl;

        else

        {

            int st = mp[from], ed = mp[to];

            memset(dis1, -1, sizeof(dis1));

            spfa(0, st, dis1);    //正向找st到各点的最短路

//            dijsktra(0, st, dis1);

            if(dis1[ed] == -1)   //不可到达

                cout << -1 << endl;

            else

            {

                __int64 ans = (__int64)1<<60;

                memset(dis2, -1, sizeof(dis2));

                spfa(1, ed, dis2);    //反向找ed到各点的最短路

//                dijsktra(1, ed, dis2);



                for(int i = 0; i < n_flight; ++i)

                    ans = min(ans, dis1[start[i]] + dis2[end[i]] + price[i]/2);



                cout << ans << endl;

            }

        }

    }

    return 0;

}