HDU 1874(简单最短路) （大优化）

优先队列那里用greater会报错

http://acm.hdu.edu.cn/showproblem.php?pid=1874

/*
使用pair代替结构
*/

#include <iostream>
#include <cstdio>
#include <queue>
#include <vector>
using namespace std;
const int Ni = 10000;
const int INF = 1<<27;

typedef pair<int,int> pa;

int dis[Ni],n;//dis使用1-n的部分

vector<pair<int,int> > eg[Ni];

void Dijkstra(int s)
{
          int i,j;
          for(i=0;i<=n;i++)//要到n
                    dis[i] = INF;
          priority_queue<pa> q;  //优先级队列：小顶堆
          dis[s] = 0;
          q.push(make_pair(s,dis[s]));

          while(!q.empty())
          {
                    pa x = q.top();
                    q.pop();
                    int w = x.first;
                    for(j = 0;j<eg[w].size();j++)//遍历x的所有邻接点
                    {
                              pa y = eg[w][j];//y是x的邻接点
                              int u = y.first;
                              if(dis[u]>x.second+y.second)
                              {
                                        dis[u] = x.second+y.second;
                                        q.push(make_pair(u,dis[u]));
                              }
                    }
          }

}


int main()
{
          int m,a,b,d;//关系个数
          while(cin>>n>>m)
          {
                    for(int i = 0;i<=n;i++)
                              eg[i].clear();//初始化
                    while(m--)
                    {
                              cin>>a>>b>>d;
                              eg[a].push_back(make_pair(b,d));
                              eg[b].push_back(make_pair(a,d));
                    }

                    int o,p;
                    cin>>o>>p;
                    Dijkstra(o);
                    if(dis[p]!=INF)
                              cout<<dis[p]<<endl;
                    else
                              cout<<"-1
";
          }

          return 0;
}
/*
6 6
1 2 2
3 2 4
1 4 5
2 5 2
3 6 3
5 6 3
*/

上面那种方法在ACM里实在太慢了（46MS），用C的话效率急速提升，达到了0MS。。

#include <cstdio>
using namespace std;
const int L = 1010;
const int INF = 1<<27;

int map[L][L];
int vis[L];
int dis[L];

int n,m;

void Dijkstra(int s)
{
          int i,j,k;
          int min;
          for(i = 0;i<n;i++)
          {
                    dis[i] = map[s][i];
                    vis[i] = 0;
          }

          vis[s] = 1;
          dis[s] = 0;

          for(i = 0;i<n;i++)
          {
                    min = INF;
                    for(j = 0;j<n;j++)
                    {
                              if(dis[j]<min && !vis[j])
                              {
                                        k = j;
                                        min = dis[j];
                              }
                    }

                    vis[k] = 1;

                    for(j = 0;j<n;j++)
                    {
                              if(dis[j] > min+map[k][j] && !vis[j])
                              {
                                        dis[j] = min+map[k][j];
                              }
                    }
          }
}

void init()
{
          int i,j;
          for(i = 0;i<n;i++)
          {
                    map[i][i] = 0;
                    for(j = i+1;j<n;j++)
                    {
                              map[i][j] = map[j][i] = INF;
                    }
          }

          while(m--)
          {
                    int a,b,w;
                    scanf("%d%d%d",&a,&b,&w);
                    if(w<map[a][b])//可能有同两点，但不同weight
                    {
                              map[a][b] = w;
                              map[b][a] = w;
                    }
          }
}


int main()
{
          while(~scanf("%d%d",&n,&m))
          {
                    int r,t;

                    init();

                    scanf("%d%d",&r,&t);

                    Dijkstra(r);

                    if(dis[t]!=INF)
                              printf("%d
",dis[t]);
                    else
                              printf("-1
");

          }

          return 0;
}