图的最短路径

广度优先算法求无权图最短路径：

bool G[500][500];
void Unweighted(int dist[],int path[],int s){
    queue<int> q;
    q.push(s);
    dist[s]=0;
    while(!q.empty()){
        int v=q.front();
        q.pop();
        for(int i=0;i<n;i++){
            if(G[v][i]==true){
                dist[i]=dist[v]+1;
                q.push(i);
            }
        }
    }
}

dijkstra算法：求解带权图中单源最短路径：

#define inf 999999
int dist[500];
int path[500];
int findMin(){
    int min=-1;
    int minDist=inf;
    for(int i=0;i<n;i++){   //n表示实际的顶点数量
        if(dist[i]<minDist&&visited[i]==false){    
            minDist=dist[i];
            min=i;
        }
    }
    return min;
}
bool dijkstra(int v){
    fill(dist,dist+500,inf);
    fill(path,path+500,-1);
    dist[v]=0;
    visited[v]=1;
    for(int i=0;i<n;i++){    
        if(G[v][i]<inf){
            dist[i]=G[v][i];    
            path[i]=v;
        }
    }
    while(1){
        int temp=findMin();
        if(temp==-1)
            break;
        visited[temp]=1;
        for(int i=0;i<n;i++){
            if(visited[i]==false){
                if(G[temp][i]<0)
                    return false;            //dijkstra无法解决带有负权值边的图的最短路径问题 
                if(dist[temp]+G[temp][i]<dist[i]){
                    dist[i]=dist[temp]+G[temp][i];
                    path[i]=temp;
                }
            }
        }
    }
    return true;
}

  floyd算法：求解图中任意两个顶点的最短距离

void floyd(){
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            for(int k=0;k<=n;k++){
                if(G[j][k]>G[j][i]+G[i][k])
                    G[j][k]=G[j][i]+G[i][k];
            }
        }
    }
}

　　floyd算法的代码很简单，但是时间复杂度较高O(n^3)，通常要求多个源点的最短路径的时候一般是多次调用dijkstra算法而不是直接使用floyd。