Invitation Cards POJ - 1511

题目链接：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 + ;
 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,,n) vis[i] = false;
     rep(i,,n) dis[i] = inf;
     dis[] = ;
     que.push(node{,});

     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,,n) ans += dis[i];
 }

 int main(){

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

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

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

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

         ans = ;
         dijkstra();  

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

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

     getchar(); getchar();
     return ;
 }