【模板】最短路

Floyd
这是DP！DP！DP！

int V, E;  
int d[MAX_V][MAX_V];  

void Floyd()  
{  
    for(int k = 1; k <= V; k+ +)  
        for(int i = 1; i <= V; i ++)  
            for(int j = 1; j <= V; j ++)  
                d[i][j] = min(d[i][j],d[i][k] + d[k][j]);  
}  

Dijkstra
贪心的最短路算法 不能处理负权

void dijkstra(int s)
{
    d[s] = 0;
    while(true)
    {
        int v = -1;
        for(int i = 1; i <= V; i ++)
            if(!done[i] && (v == -1 || d[i] < d[v]))
                v = i;
        if(v == -1) break;
        done[v] = 1;
        for(int i = first[v]; i != -1; i = next[i])
        {
            int u = es[i].to;
            d[u] = min(d[u], d[v] + es[i].cost);
        }
    }
}

SPFA

void spfa(int s)
{
    d[s] = 0;
    q.push(s);
    used[s] = 1;
    while(!q.empty())
    {
        int u = q.front();
        q.pop();
        used[u] = 0;
        for(int i = first[u]; i != -1; i = next[i])
        {
            int v = es[i].to;
            if(d[v] > d[u] + es[i].cost )
            {
                d[v] = d[u] + es[i].cost;
                if(!used[v])
                {
                    q.push(v);
                    used[v] = 1;
                }
            }
        }
    }

}