最短路

ACM模版

Dijkstra 单源最短路 邻接矩阵形式

/* *  单源最短路径，Dijkstra算法，邻接矩阵形式，复杂度为O(n^2) *  求出源beg到所有点的最短路径，传入图的顶点数和邻接矩阵cost[][] *  返回各点的最短路径lowcost[]，路径pre[]，pre[i]记录beg到i路径上的父节点，pre[beg] = -1 *  可更改路径权类型，但是权值必须为非负，下标0~n-1 */const int MAXN = 1010;const int INF = 0x3f3f3f3f; //  表示无穷bool vis[MAXN];int pre[MAXN];void Dijkstra(int cost[][MAXN], int lowcost[], int n, int beg){    for (int i = 0; i < n; i++)    {        lowcost[i] = INF;        vis[i] = false;        pre[i] = -1;    }    lowcost[beg] = 0;    for (int j = 0; j < n; j++)    {        int k = -1;        int min = INF;        for (int i = 0; i < n; i++)        {            if (!vis[i] && lowcost[i] < min)            {                min = lowcost[i];                k = i;            }        }        if (k == -1)        {            break;        }        vis[k] = true;        for (int i = 0; i < n; i++)        {            if (!vis[i] && lowcost[k] + cost[k][i] < lowcost[i])            {                lowcost[i] = lowcost[k] + cost[k][i];                pre[i] = k;            }        }    }}

Dijkstra 单源最短路 邻接矩阵形式 双路径信息

/* *  单源最短路径，dijkstra算法，邻接矩阵形式，复杂度为O(n^2) *  两点间距离存入map[][],两点间花费存入cost[][] *  求出源st到所有点的最短路径及其对应最小花费 *  返回各点的最短路径lowdis[]以及对应的最小花费lowval[] *  可更改路径权类型，但是权值必须为非负，下标1~n */const int MAXN = 1010;const int INF = 0x3f3f3f3f;int n, m;int lowdis[MAXN];int lowval[MAXN];int visit[MAXN];int map[MAXN][MAXN];int cost[MAXN][MAXN];void dijkstra(int st){    int temp = 0;    for (int i = 1; i <= n; i++)    {        lowdis[i] = map[st][i];        lowval[i] = cost[st][i];    }    memset(visit, 0, sizeof(visit));    visit[st] = 1;    for (int i = 1; i < n; i++)    {        int MIN = INF;        for (int j = 1; j <= n; j++)        {            if (!visit[j] && lowdis[j] < MIN)            {                temp = j;                MIN = lowdis[j];            }        }        visit[temp] = 1;        for (int j = 1; j <= n; j++)        {            if (!visit[j] && map[temp][j] < INF)            {                if (lowdis[j] > lowdis[temp] + map[temp][j])                {                    lowdis[j] = lowdis[temp] + map[temp][j];                    lowval[j] = lowval[temp] + cost[temp][j];                }                else if (lowdis[j] == lowdis[temp] + map[temp][j])                {                    if (lowval[j] > lowval[temp] + cost[temp][j])                    {                        lowval[j] = lowval[temp] + cost[temp][j];                    }                }            }        }    }    return ;}

Dijkstra 起点Start 结点有权值

#define M 505const int inf = 0x3f3f3f3f;int num[M];           //  结点权值int map[M][M];        //  图的临近矩阵int vis[M];           //  结点是否处理过int ans[M];           //  最短路径结点权值和int dis[M];           //  各点最短路径花费int n, m, Start, End; //  n结点数，m边数，Start起点，End终点void Dij(int v){    ans[v] = num[v];    memset(vis, 0, sizeof(vis));    for (int i = 0; i < n; ++i)    {        if (map[v][i] < inf)        {            ans[i] = ans[v] + num[i];        }        dis[i] = map[v][i];    }    dis[v] = 0;    vis[v] = 1;    for (int i = 1; i < n; ++i)    {        int u = 0, min = inf;        for (int j = 0; j < n; ++j)        {            if (!vis[j] && dis[j] < min)            {                min = dis[j];                u = j;            }        }        vis[u] = 1;        for (int k = 0; k < n; ++k)        {            if (!vis[k] && dis[k] > map[u][k] + dis[u])            {                dis[k] = map[u][k] + dis[u];                ans[k] = ans[u] + num[k];            }        }        for (int k = 0; k < n; ++k)        {            if (dis[k] == map[u][k] + dis[u])            {                ans[k] = max(ans[k], ans[u] + num[k]);            }        }    }    printf("%d %d\n", dis[End], ans[End]);  //  输出终点最短路径花费、最短路径结点权值和}int main(){    scanf("%d%d%d%d", &n, &m, &Start, &End);    for (int i = 0; i < n; ++i)    {        scanf("%d", &num[i]);    }    memset(vis, 0, sizeof(vis));    memset(map, 0x3f, sizeof(map));    for (int i = 0; i < m; ++i)    {        int x, y, z;        scanf("%d%d%d", &x, &y, &z);        if (map[x][y] > z)        {            map[x][y] = z;            map[y][x] = z;        }    }    Dij(Start);    return 0;}

Dijkstar 堆优化

/*  *  使用优先队列优化Dijkstra算法 *  复杂度O(ElongE) *  注意对vector<Edge> E[MAXN]进行初始化后加边 */const int INF = 0x3f3f3f3f;const int MAXN = 1000010;struct qNode{    int v;    int c;    qNode(int _v = 0, int _c = 0) : v(_v), c(_c) {}    bool operator < (const qNode &r) const    {        return c > r.c;    }};struct Edge{    int v;    int cost;    Edge(int _v = 0, int _cost = 0) : v(_v), cost(_cost) {}};vector<Edge> E[MAXN];bool vis[MAXN];int dist[MAXN];     //  最短路距离void Dijkstra(int n, int start)     //  点的编号从1开始{    memset(vis, false, sizeof(vis));    memset(dist, 0x3f, sizeof(dist));    priority_queue<qNode> que;    while (!que.empty())    {        que.pop();    }    dist[start] = 0;    que.push(qNode(start, 0));    qNode tmp;    while (!que.empty())    {        tmp = que.top();        que.pop();        int u = tmp.v;        if (vis[u])        {            continue;        }        vis[u] = true;        for (int i = 0; i < E[u].size(); i++)        {            int v = E[tmp.v][i].v;            int cost = E[u][i].cost;            if (!vis[v] && dist[v] > dist[u] + cost)            {                dist[v] = dist[u] + cost;                que.push(qNode(v, dist[v]));            }        }    }}void addEdge(int u, int v, int w){    E[u].push_back(Edge(v, w));}

单源最短路 BellmanFord算法

/* *  单源最短路BellmanFord算法，复杂度O(VE) *  可以处理负边权图 *  可以判断是否存在负环回路，返回true，当且仅当图中不包含从源点可达的负权回路 *  vector<Edge>E;先E.clear()初始化，然后加入所有边 */const int INF = 0x3f3f3f3f;const int MAXN = 550;int dist[MAXN];struct Edge{    int u;    int v;    int cost;    Edge(int _u = 0, int _v = 0, int _cost = 0) : u(_u), v(_v), cost(_cost){}};vector<Edge>E;bool BellmanFord(int start, int n)  //  编号从1开始{    memset(dist, 0x3f, sizeof(dist));    dist[start] = 0;    for (int i = 1; i < n; i++)     //  最多做n - 1次    {        bool flag = false;        for (int j = 0; j < E.size(); j++)        {            int u = E[j].u;            int v = E[j].v;            int cost = E[j].cost;            if (dist[v] > dist[u] + cost)            {                dist[v] = dist[u] + cost;                flag = true;            }        }        if (!flag)                  //  无负环回路        {            return true;        }    }    for (int j = 0; j < E.size(); j++)    {        if (dist[E[j].v] > dist[E[j].u] + E[j].cost)        {            return false;           //  有负环回路        }    }    return true;                    //  无负环回路}

单源最短路 SPFA

/* *  时间复杂度O(kE) *  队列实现，有时候改成栈实现会更快，较容易修改 */const int MAXN = 1010;const int INF = 0x3f3f3f3f;struct Edge{    int v;    int cost;    Edge(int _v = 0, int _cost = 0) : v(_v), cost(_cost) {}};vector<Edge> E[MAXN];void addEdge(int u, int v, int w){    E[u].push_back(Edge(v, w));}bool vis[MAXN];     //  在队列标志int cnt[MAXN];      //  每个点的入列队次数int dist[MAXN];bool SPFA(int start, int n){    memset(vis, false, sizeof(vis));    memset(dist, 0x3f, sizeof(dist));    vis[start] = true;    dist[start] = 0;    queue<int> que;    while (!que.empty())    {        que.pop();    }    que.push(start);    memset(cnt, 0, sizeof(cnt));    cnt[start] = 1;    while (!que.empty())    {        int u = que.front();        que.pop();        vis[u] = false;        for (int i = 0; i < E[u].size(); i++)        {            int v = E[u][i].v;            if (dist[v] > dist[u] + E[u][i].cost)            {                dist[v] = dist[u] + E[u][i].cost;                if (!vis[v])                {                    vis[v] = true;                    que.push(v);                    if (++cnt[v] > n)                    {                        return false;   //  cnt[i]为入队列次数，用来判定是否存在负环回路                    }                }            }        }    }    return true;}

Floyd算法 邻接矩阵形式

/* *  Floyd算法，求从任意节点i到任意节点j的最短路径 *  cost[][]:初始化为INF（cost[i][i]：初始化为0） *  lowcost[][]:最短路径，path[][]:最短路径（无限制） */const int MAXN = 100;int cost[MAXN][MAXN];int lowcost[MAXN][MAXN];int path[MAXN][MAXN];void Floyd(int n){    memcpy(lowcost, cost, sizeof(cost));    memset(path, -1, sizeof(path));    for (int k = 0; k < n; k++)    {        for (int i = 0; i < n; i++)        {            for (int j = 0; j < n; j++)            {                if (lowcost[i][j] > (lowcost[i][k] + lowcost[k][j]))                {                    lowcost[i][j] = lowcost[i][k] + lowcost[k][j];                    path[i][j] = k;                }            }        }    }    return ;}

Floyd算法 点权 + 路径限制

/* *  Floyd算法，求从任意节点i到任意节点j的最短路径 *  cost[][]:初始化为INF（cost[i][i]：初始化为0） *  val[]:点权，lowcost[][]:除起点、终点外的点权之和+最短路径 *  path[][]:路径限制，要求字典序最小的路径，下标1~N */const int MAXN = 110;const int INF = 0x1f1f1f1f;int val[MAXN];          //  点权int cost[MAXN][MAXN];int lowcost[MAXN][MAXN];int path[MAXN][MAXN];   //  i~j路径中的第一个结点void Floyd(int n){    memcpy(lowcost, cost, sizeof(cost));    for (int i = 0; i <= n; i++)    {        for (int j = 0; j <= n; j++)        {            path[i][j] = j;        }    }    for (int k = 1; k <= n; k++)    {        for (int i = 1; i <= n; i++)        {            for (int j = 1; j <= n; j++)            {                int temp = lowcost[i][k] + lowcost[k][j] + val[k];                if (lowcost[i][j] > temp)                {                    lowcost[i][j] = temp;                    path[i][j] = path[i][k];                }                else if (lowcost[i][j] == temp && path[i][j] > path[i][k])                {                    path[i][j] = path[i][k];                }            }        }    }    return ;}