最短路径 专题总结

一.模板：

1.dijsktra算法（矩阵）：

int n,cost[1005][1005],dis[1005],vis[1005],dp[1005];  
void dijkstra(int st)
{
    memset(vis,0,sizeof(vis));
    for(int i = 1; i<=n; i++)
        dis[i] = (i==st?0:INF);

    for(int i = 1; i<=n; i++)
    {
        int k, minn = INF;
        for(int j = 1; j<=n; j++)
            if(!vis[j]&&dis[j]<minn)
                minn = dis[k=j];

        vis[k] = 1;
        for(int j = 1; j<=n; j++)
            if(!vis[j] && cost[k][j]!=INF)        
                dis[j] = min(dis[j], dis[k] + cost[k][j]);
    }
}

2.dijsktra算法（前向星）：

struct edge
{
    int to, w, next;
}edge[maxn*maxn];
int cnt, head[maxn];

void addedge(int u, int v, int w)
{
    edge[cnt].to = v;
    edge[cnt].w = w;
    edge[cnt].next = head[u];
    head[u] = cnt++;
}

void init()
{
    cnt = 0;
    memset(head, -1, sizeof(head));
}

int dis[maxn], vis[maxn];
void dijkstra(int st)
{
    memset(vis, 0, sizeof(vis));
    for(int i = 1; i<=n; i++)
        dis[i] = (i==st?0:INF);

    for(int i = 1; i<=n; i++)
    {
        int k, minn = INF;
        for(int j = 1; j<=n; j++)
            if(!vis[j] && dis[j]<minn)
                minn = dis[k=j];

        vis[k] = 1;
        for(int j = head[k]; j!=-1; j = edge[j].next)
            if(!vis[edge[j].to])
                dis[edge[j].to] = min(dis[edge[j].to], dis[k] + edge[j].w);
    }
}

3.bellman-ford算法（前向星）：

struct edge
{
    int u, v, w;
}edge[maxn*maxn];
int cnt;

void addedge(int u, int v, int w)
{
    ++cnt;
    edge[cnt].u = u;
    edge[cnt].v = v;
    edge[cnt].w = w;
}

int dis[maxn];
bool bellman(int st)
{
    for(int i = 1; i<=n; i++)
        dis[i] = (i==st?0:INF);

    for(int i = 1; i<=n-1; i++)
    {
        for(int j = 1; j<=cnt; j++)
        {
            int u = edge[j].u;
            int v = edge[j].v;
            if(dis[u]!=INF)
                dis[v] = min(dis[v], dis[u]+edge[j].w);
        }
    }

    for(int i = 1; i<=cnt; i++)    //判断是否存在负环
    {
        int u = edge[i].u;
        int v = edge[i].v;
        if(dis[u]!=INF && dis[u]+edge[i].w<dis[v])
            return false;
    }
    return true;
}

4.spfa算法（前向星）：

struct edge
{
    int to, w, next;
}edge[maxn*maxn];
int cnt, head[maxn];

void addedge(int u, int v, int w)
{
    edge[cnt].to = v;
    edge[cnt].w = w;
    edge[cnt].next = head[u];
    head[u] = cnt++;
}

void init()
{
    cnt = 0;
    memset(head, -1, sizeof(head));
}

int dis[maxn], times[maxn], inq[maxn];
bool spfa(int st)
{
    memset(inq, 0, sizeof(inq));
    memset(times, 0, sizeof(times));
    for(int i = 1; i<=n; i++)
        dis[i] = (i==st?0:INF);

    queue<int>Q;
    Q.push(st);
    inq[st] = 1;
    while(!Q.empty())
    {
        int u = Q.front();
        Q.pop(); inq[u] = 0;
        for(int i = head[u]; i!=-1; i = edge[i].next)
        {
            int v = edge[i].to;
            if(dis[v]>dis[u]+edge[i].w)
            {
                dis[v] = dis[u]+edge[i].w;
                if(!inq[v])
                {
                    Q.push(v);
                    inq[v] = 1;
                    if(++times[v]>n) return false;
                }
            }
        }
    }
    return true;
}

5.floyd算法：

for(int i = 1; i<=n; i++)    
    for(int j = 1; j<=n; j++)    
        scanf("%d",&dis[i][j]);    

for(int k = 1; k<=n; k++)   
    for(int i = 1; i<=n; i++)    
        for(int j = 1; j<=n; j++)    
            dis[i][j] = min(dis[i][j], dis[i][k]+dis[k][j]);  

二.题目类型：

1.普通最短路：

POJ1511 Invitation Cards

POJ3268 Silver Cow Party 

2.最短路变形：

POJ2253 Frogger

POJ1797 Heavy Transportation

CSU1808 地铁

3.求负环或正环：

POJ3259 Wormholes

POJ1860 Currency Exchange

4.传递闭包：

POJ3660 Cow Contest

5.差分约束：

POJ3159 Candies