POJ 1511 Invitation Cards(Dijkstra(优先队列)+SPFA(邻接表优化))

题目链接：http://poj.org/problem?id=1511

题目大意：给你n个点，m条边（1<=n<=m<=1e6）,每条边长度不超过1e9。问你从起点到各个点以及从各个点到起点的最小路程总和。

解题思路：这里用了优先队列优化的dijkstra复杂度mlogn,从起点到个点最短路径直接算就好了，算各个点到起点的最短路径，只要把边的方向反一下,再算一次从起点到个点最短路径就好了。

Dijkstra:

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<functional>
 #include<vector>
 #include<queue>
 using namespace std;
 typedef long long LL;
 typedef pair<int,int> p;
 const int N=1e6+;
 const int INF=<<;//这里不能比1e9小
 struct edge{
     int to,cost;
 };
 
 vector<edge>eg[N];
 int V,E;
 bool used[N];
 int d[N];
 int a[N],b[N],c[N];
 
 void dijkstra(int s){
     for(int i=;i<=V;i++){
         d[i]=INF;
         used[i]=false;
     }
     d[s]=;
 
     priority_queue<p,vector<p>,greater<p> >q;
     q.push(p(,s));
     while(!q.empty()){
         p p1=q.top();
         q.pop();
         int v=p1.second;
         if(used[v])    continue;
         used[v]=true;
         for(int i=;i<eg[v].size();i++){
             edge e=eg[v][i];
             if(d[e.to]>d[v]+e.cost){
                 d[e.to]=d[v]+e.cost;
                 q.push(p(d[e.to],e.to));
             }
         }
     }
 } 
 
 int main(){
     int q;
     scanf("%d",&q);
     while(q--){
         scanf("%d %d",&V,&E);
         for(int i=;i<=V;i++){
             eg[i].clear();
         }
         for(int i=;i<=E;i++){
             scanf("%d%d%d",&a[i],&b[i],&c[i]);
             edge gg;
             gg.to=b[i],gg.cost=c[i];
             eg[a[i]].push_back(gg);
         }
         dijkstra();
         LL sum=;
         for(int i=;i<=V;i++){
             sum+=d[i];
         }
         //将边的方向反一下
         for(int i=;i<=V;i++){
             eg[i].clear();
         }
         for(int i=;i<=E;i++){
             edge gg;
             gg.to=a[i],gg.cost=c[i];
             eg[b[i]].push_back(gg);
         }
         dijkstra();
         for(int i=;i<=V;i++){
             sum+=d[i];
         }
         printf("%lld\n",sum);
     }
 }

SPFA:

 #include<iostream>
 #include<queue>
 #include<vector>
 using namespace std;
 const int INF=<<;
 const int N=1e6+;
 
 struct edge{
     int to,cost;
 }; 
 
 vector<edge>eg[N];
 int V,E;
 bool used[N];//是否在队列中
 int d[N];
 int a[N],b[N],c[N];
 
 void spfa(int s){
     for(int i=;i<=V;i++){
         d[i]=INF;
         used[i]=false;
     }
     d[s]=;
 
     queue<int>q;
     q.push(s);
     used[s]=true;
     while(!q.empty()){
         int v=q.front();
         q.pop();
         used[v]=false;
         for(int i=;i<eg[v].size();i++){
             edge e=eg[v][i];
             if(d[e.to]>d[v]+e.cost){
                 d[e.to]=d[v]+e.cost;
                 if(!used[e.to]){
                     used[e.to]=true;
                     q.push(e.to);
                 }
             }
         }
     }
 } 
 
 int main(){
     int q;
     scanf("%d",&q);
     while(q--){
         scanf("%d%d",&V,&E);
         for(int i=;i<=V;i++){
             eg[i].clear();
         }
         for(int i=;i<=E;i++){
             scanf("%d%d%d",&a[i],&b[i],&c[i]);
             edge gg;
             gg.to=b[i],gg.cost=c[i];
             eg[a[i]].push_back(gg);
         }
         spfa();
         long long sum=;
         for(int i=;i<=V;i++){
             sum+=d[i];
         }
         //方向反一下
         for(int i=;i<=V;i++){
             eg[i].clear();
         }
         for(int i=;i<=E;i++){
             edge gg;
             gg.to=a[i],gg.cost=c[i];
             eg[b[i]].push_back(gg);
         }
         spfa();
         for(int i=;i<=V;i++){
             sum+=d[i];
         }
         printf("%lld\n",sum);
     }
 }