hdu 1874 最短路径 dijkstra 和floyd 算法

dijkstra  算法：

#include<iostream>
#include<stdlib.h>
#include<algorithm>
#include<limits.h>
using namespace std;
const int NP=210;
const int MP=1010;
int map[NP][NP];
int  dijkstra(int p,int t,int maxNode)
{
      bool visited[NP];
      int shortdist;
      int dist[NP];
      int index=-1;
      for(int i=0;i<maxNode;i++)
      {
            visited[i]=0;
            dist[i]=map[p][i]; 
      }  
      visited[p]=1;
      for(int i=0;i<maxNode-1;i++)
      {
            int min=INT_MAX;
            for(int j=0;j<maxNode;j++)
            {
                  if(!visited[j]&&dist[j]<min)
                  {
                        min=dist[j];
                        index=j;
                  }
            }
            visited[index]=1;
            for(int j=0;j<maxNode;j++)
            {
                   if(!visited[j]&&map[index][j]!=INT_MAX) 
                   {    
                        if(map[index][j]+dist[index]<dist[j])
                        dist[j]=map[index][j]+dist[index];
                   }
            }
      }
      if(dist[t]!=INT_MAX)
      return dist[t];
      else
      return -1;
 

}
int main()
{
      int N,M,S,T,A,B,X;
      while(scanf("%d%d",&N,&M)!=EOF)
      {
            
            for(int i=0;i<N;i++)
                  for(int j=0;j<N;j++)
                  map[i][j]=INT_MAX;  
            for(int i=0;i<N;i++)
                  map[i][i]=0;      
            for(int i=0;i<M;i++)
            {
                  cin>>A>>B>>X;
                  //maxNode=(max(A,B)>maxNode)?max(A,B):maxNode;
                  map[A][B]=map[B][A]=(X>map[A][B])?map[A][B]:X;
                  
            }
            
            cin>>S>>T;
            int f=dijkstra(S,T,N);
            
            
            cout<<f<<endl;
      }
      system("pause");
      return 0;
}
                                                                
                                     
              
       

floyd 算法：

#include<iostream>
#include<stdlib.h>
#include<algorithm>
#include<limits.h>
using namespace std;
const int NP=210;
const int MP=1010;
int map[NP][NP];
void floyd(int M)
{
     for(int i=0;i<M;i++)
           for(int j=0;j<M;j++)
                 for(int k=0;k<M;k++)
                 if(map[k][i]+map[j][i]<map[k][j])
                 map[k][j]=map[k][i]+map[j][i];
} 
int main()
{
      int N,M,S,T,A,B,X;
      while(scanf("%d%d",&N,&M)!=EOF)
      {
            
            for(int i=0;i<N;i++)
                  for(int j=0;j<N;j++)
                  map[i][j]=INT_MAX;  
            for(int i=0;i<N;i++)
                  map[i][i]=0;      
            for(int i=0;i<M;i++)
            {
                  cin>>A>>B>>X;
                  //maxNode=(max(A,B)>maxNode)?max(A,B):maxNode;
                  map[A][B]=map[B][A]=(X>map[A][B])?map[A][B]:X;
                  
            }
            
            cin>>S>>T;
            floyd(N);
            if(map[S][T]<INT_MAX)
            cout<<map[S][T]<<endl;
            else
            cout<<"-1"<<endl;
      }
      system("pause");
      return 0;
}