最短路

最新推荐文章于 2024-01-20 10:42:41 发布
最新推荐文章于 2024-01-20 10:42:41 发布
阅读量4.5k 收藏 13
点赞数 3
分类专栏： ACM模版篇 图论 ACM模板-f_zyj 文章标签： 最短路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/f_zyj/article/details/51596071
版权
图论 同时被 3 个专栏收录
168 篇文章 0 订阅
订阅专栏
ACM模版篇
156 篇文章 21 订阅
订阅专栏
ACM模板-f_zyj
147 篇文章 72 订阅
订阅专栏

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 505

const 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[u][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 ;
}
f_zyj
关注
  • 3
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 13
    评论
专栏目录
几种最短路的算法（4种）
qq_46258869的博客
08-10 831
FLoyd算法 适用范围：无负权回路即可，边权可正可负，运行一次算法即可求得任意两点间最短路（多源最短路）。 具体来说：这是是一种dp算法，稠密图效果最佳，对于稠密图，效率要高于执行Dijkstra。时间复杂度为O(N^3)，空间复杂度为O(N^2)。 好的博客：最短路径模板+解析——（FLoyd算法） 模板题目：六度分离 #include<stdio.h> #include<cstring> using namespace std; const int INF = 0x
最短路问题
sky的博客
04-09 3512
转载自：https://mp.weixin.qq.com/s/4G77pVgfHuPHjGDmfc27ZA 1.什么是最短路问题 最短路问题（shortest-path problem）是图论中的经典问题之一，可用来解决管路铺设、线路安装、厂区布局和设备更新等实际问题。 基本内容是：假设网络中的每条边都有一个权重（常用长度、成本、时间等表示），最短路问题的目标是找出给定两点（通常是源节点和汇节点）之间总权重之和最小的路径。 如上图所示，以1为起点，7为终点，则...
从入门角度深入理解——有关最短路的常见算法#1 最短路问题介绍
wdshhh的博客
05-25 883
最短路问题介绍 这里的最短路问题，指的是单源最短路。 单源最短路，意如其名，只有一个原点，走到其他点的最短路径。 即求一个点到其余点的最短路径。 图的简单概述： 要了解最短路，首先要简单理解一下什么是图。 书上概述如下（可以跳过不读）： 图G=（V,E）是一个二元组（V,E）使得E⊆[V]的平方，所以E的元素是V的2-元子集。为了避免符号上的混淆，我们总是默认V∩B=Ø。集合V中的元素称为图G的顶点（或节点、点），而集合E的元素称为边（或线）。通常，描绘一个图的方法是把顶点画成一个小圆圈，如果相应的顶点之
最短路问题及其求解方法
weixin_42339924的博客
03-13 1952
外部网络数据导入计算最短路的Dijkstra算法（Matlab）
图论：最短路（dijkstra算法、bellman算法、spfa算法、floyd算法）详细版
northheng127的博客
01-20 1639
终于是学完了，这个最短路我学了好几天，当然也学了别的算法啦，也是非常的累啊。话不多说下面看看最短路问题吧。最短路问题是有向图，要求的是图中一个点到起点的距离，其中我们要输入点和点之间的距离，来求最短路。
matlab最短路.txt
08-11
matlab最短路.txt
Floyd最短路
01-03
Floyd最短路matlab算法，经典的运筹学问题。hiuhoojjljljpiojupo
专题·最短路【including Dijkstra， SPFA，Floyd，传递闭包，二维最短路，分层图最短路，最短路计数……
樱狸✨愿携清风归来处
05-31 1万+
DIj算法，堆优化版本，线段树优化版本； SPFA算法，Floyd算法，传递闭包； 如标题的各种最短路的应用
PAT (Advanced Level) 1003 - Emergency（单元最短路）
Snakeflute的博客
11-15 595
Emergency (25) 时间限制 400 ms 内存限制 65536 kB 代码长度限制 16000 B 判题程序 Standard 作者 CHEN, Yue As an emergency rescue team leader of a city, you are given a special map of your country. The map shows sev
旋转卡壳——凸多边形间最小距离
ACMaker的专栏
10-29 7192
凸多边形间最小距离给定两个非连接（比如不相交）的凸多边形 P 和 Q， 目标是找到拥有最小距离的点对 (p,q) （p 属于 P 且 q 属于 Q）。 事实上， 多边形非连接十分重要， 因为我们所说的多边形包含其内部。 如果多边形相交， 那么最小距离就变得没有意义了。 然而， 这个问题的另一个版本， 凸多边形顶点对间最小距离对于相交和非相交的情况都有解存在。 回到我们的主问题： 直观的， 确定最小
最短路径详解
热门推荐
某科学的程序员
05-05 2万+
Floyd-Warshall 原理 实现 Dijkstra 简单粗暴的原理 过程 实现 Spfa 原理 证明 实现 Bellman-Ford 最短路径：一个图里有很多边，每条边有权值，两点之间的权值最小的路径。 负权回路：一个环（某点出发走了一圈还回到原点）里的权值和为负数（环里的每个权值可正可负，但和为负）。 首先，存在负权回路的图里没有最短路，因为只要一直走这个回...
light oj 1057 Collecting Gold(状态压缩dp)
fisty
08-25 1254
思路：假设黄金数量一共有k个，给这些黄金编号为0 ~ k-1并且把他们的位置都存起来。起点编号为k 那么定义dp[s][i] : 当前已经采集的黄金集合为s, 并且现在处于编号为k的位置 对于将要采集的黄金编号 j ,有如下转移方程 d[s | (1 初始点为dp[0][k] = 0; 终点也为dp[0][k]，是经典的TSP问题. /**********************
最短路的四种求法详解+模板
lxt_Lucia的博客
06-08 4251
欢迎访问https://blog.csdn.net/lxt_Lucia～～   宇宙第一小仙女\(^o^)/～～萌量爆表求带飞=≡Σ((( つ^o^)つ~dalao们点个关注呗～～     一.最短路之Floyd算法         Floyd算法虽然时间复杂度不是最短的，但是代码是最简单的最短的啦～   1.介绍 　　floyd算法只有五行代码，代码简单，三个for循环就可以解决...
Pollution
news
08-12 724
Pollution is one of the biggest problems all over the world. Our earth is getting dirtier because we dont do the right things. A good environment can help us study better and so on, so we should pr
matlab求最短路
最新发布
05-24
在 MATLAB 中求解最短路问题可以使用 graphshortestpath 函数。graphshortestpath 函数可以用于求解有向图和无向图的最短路径问题，可以指定起点和终点，还可以考虑边的权重。以下是使用 graphshortestpath 函数求解...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值