**最短路径Dijkstra练习（牛客14352 旅行）**

出自南昌理工学院ACM集训队
时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 32768K，其他语言65536K
64bit IO Format: %lld

题目描述
小z放假了，准备到RRR城市旅行，其中这个城市有N个旅游景点。小z时间有限，只能在三个旅行景点进行游玩。小明租了辆车，司机很善良，说咱不计路程，只要你一次性缴费足够，我就带你走遍RRR城。
小z很开心，直接就把钱一次性缴足了。然而小z心机很重，他想选择的路程尽量长。
然而司机也很聪明，他每次从一个点走到另外一个点的时候都走最短路径。
你能帮帮小z吗？
需要保证这三个旅行景点一个作为起点，一个作为中转点一个作为终点。（一共三个景点，并且需要保证这三个景点不能重复）.
输入描述:
本题包含多组输入，第一行输入一个整数t，表示测试数据的组数
每组测试数据第一行输入两个数N,M表示RRR城一共有的旅游景点的数量，以及RRR城中有的路的数量。
接下来M行，每行三个数，a，b，c表示从a景点和b景点之间有一条长为c的路
t<=40
3<=N,M<=1000
1<=a,b<=N
1<=c<=100
输出描述:
每组数据输出两行，
每组数据包含一行，输出一个数，表示整条路程的路长。
如果找不到可行解，输出-1.
示例1
输入
4
7 7
1 2 100
2 3 100
1 4 4
4 5 6
5 6 10
1 6 4
6 7 8
7 3
1 2 1
1 3 1
1 3 2
7 3
1 2 1
3 4 1
5 6 1
8 9
1 2 1
2 3 1
3 4 1
4 1 1
4 5 1
5 6 1
6 7 1
7 8 1
8 5 1

输出
422
3
-1
9
说明
请注意这是一个稀疏图.

这是题目链接：牛客14352（旅行）

一，题解
1.这个题首先是个无向图且是稀疏的，那么我们使用邻接表来存储信息，我这里用的链式前象星存储的

struct Node            //邻接表信息
{
    int to,w,next;
}s[N*2];

void add(int u,int v,int w)           //链式前向星存储邻接表
{
    s[tot].to = v;
    s[tot].w = w;
    s[tot].next = h[u];
    h[u] = tot++;
}

for(int i = 1; i <= m; i++)
{
    cin >> x >> y >> z;

    add(x,y,z);                    //无向图所以要x,y调换位置存两次
    add(y,x,z);
}

2.这个题不是单纯的让我们找出最短路，而是规定必须至少经过三个点且让之间所消耗的代价越大越好。
那么首先，司机也不是傻子，两个点之间肯定会走最短的路（这里就是用Dijkstra的时候）。
接下来，如果我们直接考虑从起点开始找寻代价最大的走法的话那么就是先找到起始点到中转点最大的最短路，再从中转点找到起始点以外的最短路最大的点。但其实，我们发现两次最大的最短路都和中转点有关，而且肯定是中转点到其他点的最短路中其中最大的两条，那么其实这个思路可以可以转化为 中转点到各个点的最短路中选出最大的两条路。
最后，我们就使用Dijkstra算法来找到每个点到其他点的最短路，再从中找出最大的两条最短路进行相加。

int Dijkstra(int u)
{
    priority_queue <Node2> p;                //结构体类型的优先队列
    int q = 1;

//    cout << u << '|';                   //测试用的
    memset(vis,0,sizeof(vis));
    memset(cost,M,sizeof(cost));

    cost[u] = 0;
    e[q].cost1 = 0;
    e[q].to = u;
    p.push(e[q]);

    max1 = 0,max2 = 0;

    while(!p.empty())           //判断队列是否为空
    {
        int x = p.top().to;          //枚举每个点

//        cout << x << '-' << cost[x] << ' ';        //也是测试用的
        p.pop();

        if(vis[x]++)   continue;

        max2 = max(max2,cost[x]);
        if(max1 < max2)    swap(max1,max2);

        for(int i = h[x]; i != -1; i = s[i].next)
        {
            int to = s[i].to;

            if(!vis[to] && cost[x] + s[i].w <= cost[to])        //松弛操作
            {
                cost[to] = cost[x] + s[i].w;
                q++;
                e[q].cost1 = cost[to];
                e[q].to = to;
                p.push(e[q]);                      //松弛过的点才可能影响后面的点
            }
        }
    }
    if(max2 == 0)  return -1;               //没有路就是-1
    return max1 + max2;                      //以每个点为起始点所找到的所有最短路中最长的两条路的代价
}

3.因为要找出最大的那个方法，所以要枚举每个点作为中转点，将他们从第二步的出来的结果进行比较，从中得出最大的那个结果。

for(int i = 1; i <= n; i++)
{
    road = Dijkstra(i);
    max_road = max(road,max_road);               //用来得出 各个点作为中转点 所得出两条最大的最短路之和之间谁最大
}

二.图示举例
1.第一组的连通网：

2.以此得出各个点到其他点的最短路

3.得出每个点到其它点的所有最短路中最大的两个

4.将每个点最大的两条最短路相加

5.将4中数据进行比较选择出最大的

三.完整代码

#include <iostream>                  //牛客14352（旅行）最短路径
#include <string.h>
#include <algorithm>                 //这个题可以换一种想法   起点到终点走的路要最大可以转化为 中转点到各个点的最短路中选出最大的两条路
#include <queue>

using namespace std;
#define IOS std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
#define N 1005
#define M 0x3f

int n,m,x,y,z;
int h[N];
int tot = 1,max_road = 0;
int vis[N],cost[N];
int max1,max2;

struct Node            //邻接表信息
{
    int to,w,next;
}s[N*2];
struct Node2           //为了将满足收敛条件后生成的数据入队
{
    int cost1,to;            
    friend bool operator < (Node2 x,Node2 y)        //使队列中的数据按cost1的值升序排列
    {
        return x.cost1 > y.cost1;
    }
}e[N*2];

void add(int u,int v,int w)           //链式前向星存储邻接表
{
    s[tot].to = v;
    s[tot].w = w;
    s[tot].next = h[u];
    h[u] = tot++;
}

int Dijkstra(int u)
{
    priority_queue <Node2> p;                //结构体类型的优先队列
    int q = 1;

//    cout << u << '|';                   //测试用的
    memset(vis,0,sizeof(vis));
    memset(cost,M,sizeof(cost));

    cost[u] = 0;
    e[q].cost1 = 0;
    e[q].to = u;
    p.push(e[q]);

    max1 = 0,max2 = 0;

    while(!p.empty())           //判断队列是否为空
    {
        int x = p.top().to;          //枚举每个点

//        cout << x << '-' << cost[x] << ' ';        //也是测试用的
        p.pop();

        if(vis[x]++)   continue;

        max2 = max(max2,cost[x]);
        if(max1 < max2)    swap(max1,max2);

        for(int i = h[x]; i != -1; i = s[i].next)
        {
            int to = s[i].to;

            if(!vis[to] && cost[x] + s[i].w <= cost[to])        //松弛操作
            {
                cost[to] = cost[x] + s[i].w;
                q++;
                e[q].cost1 = cost[to];
                e[q].to = to;
                p.push(e[q]);                      //松弛过的点才可能影响后面的点
            }
        }
    }
    if(max2 == 0)  return -1;               //没有路就是-1
    return max1 + max2;                      //以每个点为起始点所找到的所有最短路中最长的两条路的代价
}

int main()
{
    IOS;

    int t;

    cin >> t;

    while(t--)
    {
        int road = 0;
        tot = 1,max_road = -1;
        memset(h,-1,sizeof(h));           //初始化，用来判断是否有后继结点

        cin >> n >> m;

        for(int i = 1; i <= m; i++)
        {
            cin >> x >> y >> z;

            add(x,y,z);                    //无向图所以要x,y调换位置存两次
            add(y,x,z);
        }

        for(int i = 1; i <= n; i++)
        {
            road = Dijkstra(i);
            max_road = max(road,max_road);               //用来得出 各个点作为中转点 所得出两条最大的最短路之和 之间谁最大
        }

        cout << max_road << endl;
    }
}