L2-3 超级玛丽

假定有n个城堡，编号为1至n，有的城堡之间有道路直接相连，有的城堡之间没有道路直接相连。马里奥现在准备从一个城堡出发前往另一个城堡，它有一个魔法棒，可以瞬时通过一条道路，即以0时间通过这条道路，但魔法棒最多只能用一次。马里奥想以最短的时间到达目的地，请编写程序为马里奥选定一条路线以及在什么地方使用魔法棒。假定所有道路为双向，保证从起点肯定能到达目的地。

输入格式:

输入第一行为4个整数n、s、t、m，分别表示城堡数（编号为1至n，n不超过10000），马里奥所在的起点s和想去的终点t，城堡间的道路数目。接下来m行，每行为3个正整数a、b、c，表示城堡a和城堡b之间有一条道路直接相连，通过该道路需要c分钟。

输出格式:

输出为空格间隔的2个整数，第1个整数为马里奥从起点到目的地所需的最短时间；第2个整数表示使用魔法棒的地点，即城堡编号，若有多个可能的地点，则输出编号最小者。

输入样例:

4 1 4 4
1 2 9
2 4 1
1 3 3
3 4 5

输出样例:

1 1

 思路:

 搜两次，一次搜从s开始的最短路结果，第二次搜从t开始的最短路结果，遍历每一条边(from, to)，将此边权重设为0后的s->t最短路径应该是s>from + to>t，找到值最小的就是咱们的答案

不幸的是:

该题极限是10000个节点，侥幸用邻接矩阵存图，结果还是内存超限，那好，换邻接表存储 T_T

测试点没说多少条边，也不知道是怎么回事，普通的Dijkstra搜两次结果超时，那好，用堆优化Dijkstra算法 T_T

参考代码:

#include<cstring>
#include<iostream>
#include<vector>
#include<cmath>
#include<algorithm>
#include<queue>
using namespace std;


const int MAXSIZE = 10000 + 1;
const int INVALID = 0x7FFFFFFF;
vector<pair<int, int>> adjacencyList[MAXSIZE];
int n, m;
int start, endPoint;
pair<int, int> edges[MAXSIZE];

void setDistance(int from, int to, int distance) {
    for(auto& adjacent:adjacencyList[from]) {
        if(adjacent.first == to) {
            adjacent.second = distance;
            return;
        }
    }
    adjacencyList[from].push_back({to, distance});
}

int getDistance(int from, int to) {
    for(auto& adjacent:adjacencyList[from]) {
        if(adjacent.first == to) {
            return adjacent.second;
        } else if(adjacent.first > to) {
            return INVALID;
        }
    }
    return INVALID;
}

void init() {
    scanf("%d %d %d %d", &n, &start, &endPoint, &m);
    for(int i=0;i<m;++i) {
        int from, to, distance;
        scanf("%d %d %d", &from, &to, &distance);
        adjacencyList[from].push_back({to, distance});
        adjacencyList[to].push_back({from, distance});
        edges[i] = {from, to};
    }
    for(int i=1;i<=n;++i) {
        sort(adjacencyList[i].begin(), adjacencyList[i].end(), 
             [](const auto& lhs, const auto& rhs) -> bool { return lhs.first < rhs.first; });
    }
}

// 普通的Dijkstra已经不能在战场上挥斥方遒了
vector<int> dijkstra(int startPoint) {
    vector<int> distance(n+1, INVALID);
    vector<bool> visited(n+1, false);
    for(int i=1;i<=n;++i) {
        distance[i] = getDistance(startPoint, i);
    }
    distance[startPoint] = 0;
    visited[startPoint] = true;
    for(int j=0;j<n;++j) {
        int minDis = INVALID;
        int minPoint = -1;
        for(int i=1;i<=n;++i) {
            if(!visited[i] && distance[i] < minDis) {
                minDis = distance[i];
                minPoint = i;
            }
        }
        if(minPoint == -1) break;
        visited[minPoint] = true;
        for(int i=1;i<=n;++i) {
            int curDis = getDistance(i, minPoint);
            if(!visited[i] && curDis != INVALID && curDis + minDis < distance[i]) {
                distance[i] = curDis + minDis;
            }
        }
    }
    return distance;
}

struct Node {
    int point, cost;
    
    bool operator < (const Node & rhs) const {
        if(cost==rhs.cost) return point<rhs.point;  
        return cost > rhs.cost;  
    }
};

// 堆优化Dijkstra算法简单好用
vector<int> dijkstra_heap(int startPoint) {
    int i = 0;
    vector<int> dis(n+1, INVALID);
    dis[startPoint] = 0;
    // 用优先队列优化
    priority_queue<Node> q;
    q.push({startPoint,dis[startPoint]});
    while(!q.empty()) {
        Node node = q.top();
        q.pop();
        for(i=0;i<adjacencyList[node.point].size();i++) {
            auto y = adjacencyList[node.point][i];
            int point = y.first;
            int cost = y.second;
            if(dis[point]>node.cost+cost) {
                dis[point]=node.cost+cost;
                q.push({point,dis[point]});
            }
        }
    }
    return dis;
}

int main() {
    init();
    int minTime = INVALID;
    int changeStart = -1;
    vector<int> startInStart = dijkstra_heap(start);
    vector<int> startInEnd = dijkstra_heap(endPoint);
    for(int i=0;i<m;++i) {
        int from = edges[i].first;
        int to = edges[i].second;
        if(startInStart[from] == INVALID || startInEnd[to] == INVALID) {
            continue;
        }
        int time = startInStart[from] + startInEnd[to];
        if(time < minTime || (time == minTime && min(from, to) < changeStart)) {
            minTime = time;
            changeStart = min(from, to);
        }
    }
    cout<<minTime<<" "<<changeStart<<endl;
    return 0;
}