最短路问题

a.初始时，S只包含源点，即S＝{v}，v的距离为0。U包含除v外的其他顶点，即:U={其余顶点}，若v与U中顶点u有边，则<u,v>正常有权值，若u不是v的出边邻接点，则<u,v>权值为∞。

b.从U中选取一个距离v最小的顶点k，把k，加入S中（该选定的距离就是v到k的最短路径长度）。

c.以k为新考虑的中间点，修改U中各顶点的距离；若从源点v到顶点u的距离（经过顶点k）比原来距离（不经过顶点k）短，则修改顶点u的距离值，修改后的距离值的顶点k的距离加上边上的权。

d.重复步骤b和c直到所有顶点都包含在S中。

const int MAX =100 ;
const int INF = 1<<30;
int cost[MAX][MAX];//cost[u][v] 表示e=（u,v）的权值
int d[MAX];
bool used[MAX];//顶点是否已经确定
int V;
void dijkstra(int s){
    fill(d,d+V;INF);
    fill(used,used+V,false);
    d[s]  = 0;
    while(true){
        int v = -1;
        for(int u=0;u<V;u++){
            if(!used[u] && (v==-1 || d[u]<d[v])) v = u;
        }
        if(v==-1) break;
        used[v] = true;

        for(int u=0;i<V;i++){
            d[u] = min(d[u],d[v]+cost[v][u]);
        }
    }
}

代码：

struct edge{int from ,to,cost};
 const int MAX =100 ;
 const int INF = 1<<30;
 typedef pair<int,int> P;//first 最短距离,second 编号
 int V;
 vector<int> G[MAX];
 int d[MAX];
 void dijkstra(int s){
    fill(d,d+V;INF);
    d[s] = 0;
    priority_queue<P, vecotr<P>, greater<P> > que;
    que.push(P(0,s);
    while(!qie.empty()){
        P p = que.top();
        que.pop();
        int v = p.second;
        if(d[v]<p.first){
            continue;
        }
        for(int i=0;i<G[v].size();i++){
            egde e = G[v][i];
            if(d[e.to]>d[e.from]+cost){
                d[e.to] = d[e.from]+cost;
                que.push(P(d[e.to],e.to));
            }
        }
    }
 }

Floyd-Warshall算法：

int dp[MAX][MAX];
int V;
void warshall_floyd(){
    for(int k=0;k<V;k++)
        for(int i = 0;i<V;i++)
            for(int j=0;j<v;j++)
                dp[i][j] = min(dp[i][j],dp[i][k]+dp[k][j]);
}