Invitation Cards POJ

题目链接：https://vjudge.net/problem/POJ-1511

思路：题目意思就是，从1出发到所有城市，再从所有城市回到1的最短时间。

那么我们只要正跑一次图，然后反向存边，再跑一次图，把所有单源最短路相加就是答案了。

emmm,这题，很卡时间，作为一个懒人，用c++的输入输出，加了简单的快读，用了链式前项星，

还是险些通过，感觉遇到很大的输入数据，用c++时，最好减少空间申请和回收的开销，不然会卡。

我一个优先队列在函数申请用，T了，在全局申请，再清空就A了。。。当然，这是之前的，后面改了下，

emm，7780ms。。。当然，这题用dijkstra一定要堆优化一下，点有1e6之多。。。

---

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <string>
#include <map>
#include <cmath>
#include <iomanip>
using namespace std;
 
typedef long long LL;
#define inf 1e10
#define rep(i,j,k) for(int i = (j); i <= (k); i++)
#define rep__(i,j,k) for(int i = (j); i < (k); i++)
#define per(i,j,k) for(int i = (j); i >= (k); i--)
#define per__(i,j,k) for(int i = (j); i > (k); i--)

const int N = 1e6 + 10;
int head[N];
int vis[N];
int dis[N];
int U[N],V[N],W[N];
int cnt;
LL ans;

int n,m;

struct Edge{
    int to;
    int w;
    int next;
}e[N];

struct node{
    int loc;
    int w;

    bool friend operator< (const node& a,const node& b){
        return a.w > b.w;
    }
};
priority_queue<node > que;

void add(int u,int v,int w){
    e[cnt].to = v;
    e[cnt].w = w;
    e[cnt].next = head[u];
    head[u] = cnt++;
}

void dijkstra(){

    while(!que.empty()) que.pop();
    rep(i,1,n) vis[i] = false;
    rep(i,1,n) dis[i] = inf;
    dis[1] = 0;
    que.push(node{1,0});

    while(!que.empty()){
        int u = que.top().loc;
        que.pop();
        if(vis[u]) continue;
        vis[u] = true;

        for(int o = head[u]; ~o; o = e[o].next){
            int v = e[o].to;
            int w = e[o].w;

            if(!vis[v] && dis[v] > dis[u] + w){
                dis[v] = dis[u] + w;
                que.push(node{v,dis[v]});
            }
        }
    }
    rep(i,1,n) ans += dis[i];
}

int main(){

    ios::sync_with_stdio(false);
    cin.tie(0);

    int T;
    cin >> T;
    while(T--){
        cin >> n >> m;

        rep(i,1,n) head[i] = -1;
        cnt = 0;

        int u,v,w;
        rep(i,1,m){
            cin >> U[i] >> V[i] >> W[i];
            add(U[i],V[i],W[i]); //正向存边
        }

        ans = 0;
        dijkstra();  

        rep(i,1,n) head[i] = -1;
        cnt = 0;
        rep(i,1,m){
            add(V[i],U[i],W[i]); //反向存边
        }

        dijkstra();
        cout << ans << endl;
    }

    getchar(); getchar();
    return 0;
}