Dijkstra专题——所有边权必须非负

最新推荐文章于 2023-01-18 11:22:45 发布
最新推荐文章于 2023-01-18 11:22:45 发布
阅读量454 收藏
点赞数
分类专栏： 算法技巧
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ur_ytii/article/details/113186695
版权

目录

基础情况

邻接矩阵版dijkstra，无pre数组。O（V^2)

邻接表版dijkstra，无pre数组。O( V^2+E )

邻接矩阵版dijkstra，有pre数组

拓展情况（即增加第二标尺，第一标尺是距离），求第一标尺的同时求第二标尺【推荐】

新增边权（假设为花费）

新增点权（假设是城市中能收集到的物资）

求最短路径条数

先求所有最短路径，然后求第二标尺（dijkstra+dfs）【难】

记录所有最短路径，vector pre[MAXN]

遍历所有最短路径找出第二标尺最优的路径

dfs函数

calcu函数（计算边权或者点权）：

模板完整版：

基础情况

邻接矩阵版dijkstra，无pre数组。O（V^2)

三步走：

  1. 初始化d数组
  2. 找n次当前离s最近的点加入
  3. 每次都要更新由于新加入点带来的变化 
//邻接矩阵版dijkstra
const int maxn = 1010;
const int INF = 0x3fffffff;
int n, g[maxn][maxn];
int d[maxn];//起点到各店的最短路径长度
bool vis[maxn] = { false };
void dijkstra(int s) {//s是起点
        //1  初始化d数组
	fill(d, d + maxn, INF);//开始时顶点到所有点的距离都是INF
	d[s] = 0;

        //2  找n次到离s最近的点
	for (int i = 0; i < n; i++) {
		int u = -1;//可用于后面判断是否找到小于INF的d[u],找不到说明剩下的点和s不连通
		int minn = INF;


		for (int j = 0; j < n; j++) {//寻找未访问顶点中距离起点最近的点
			if (vis[j] == false && d[j] < minn) {
				u = j;//若最后u不变（仍未-1），说明与s连通的点都已找完
				minn = d[j];
			}
		}
		if (u == -1)return;

                //3  更新由于新加进结点产生的变化，包括vis数组和距离的变化
		vis[u] = true;//标记u为已访问
		for (int v = 0; v < n; v++)
			if (vis[v] == false && d[u] + g[u][v] < d[v])
				d[v] = d[u] + g[u][v];
	}
}

邻接表版dijkstra，无pre数组。O( V^2+E )

还是三步走：

  1. 初始化d数组
  2. 找n次当前离s最近的点加入
  3. 每次都要更新由于新加入点带来的变化，这里由于是node结构体，所以用adj [u][ j]. v表示可达点，用adj [u ][j ].dis表示距离
const int maxn = 1010;
const int INF = 0x3fffffff;
struct node {
	int v;//边的目标顶点
	int dis;//权值
};
vector<node> adj[maxn];//邻接表
int n, d[maxn];
bool vis[maxn] = { false };

void dijkstr(int s) {
	//1  初始化
	fill(d, d + maxn, INF);
	d[s] = 0;

	//2  找n次最近点
	for (int i = 0; i < n; i++) {
		int u = -1;
		int minn = INF;
		for (int j = 0; j < n; j++) {
			if (vis[j] == false && d[j] < minn) {
				u = j;
				minn = d[j];
			}
		}
		if (u == -1)return;

		//3  更新
		vis[u] = true;
		for (int j = 0; j < adj[u].size(); j++) {
			int v = adj[u][j].v;
			if (vis[v] == false && d[u] + adj[u][j].dis < d[v])
				d[v] = d[u] + adj[u][j].dis;
		}

	}
}

邻接矩阵版dijkstra，有pre数组


const int maxn = 1010;
const int INF = 0x3fffffff;
int n, g[maxn][maxn], d[maxn];
bool vis[maxn] = { false };
int pre[maxn];//记录前驱

void dijkstra(int s) {
	//1  
	fill(d, d + maxn, INF);
	d[s] = 0;

	//2
	for (int i = 0; i < n; i++) {
		int u = -1, minn = INF;
		for(int j=0;j<n;j++)
			if (vis[j] == false && d[j] < minn) {
				u = j;
				minn = d[j];
			}
		if (u == -1)return;

		//3
		vis[u] = true;
		for (int v = 0; v < n; v++) {
			if (vis[v] == false && d[u] + g[u][v] < d[v]) {
				d[v] = d[v] + g[u][v];
				pre[v] = u;//记录v的前驱为u
			}
		}
	}
}

void dfs(int s, int v) {
	if (v == s) {//若当前v是起点s，则输出起点并返回
		printf("%d\n", s);
		return;
	}
	dfs(s, pre[v]);
	printf("%d\n", v);//从最深处回来后，输出每层编号
}

拓展情况（即增加第二标尺，第一标尺是距离），求第一标尺的同时求第二标尺【推荐】

有三种：给每条边增加一个边权，给每个点增加一个点权，直接问有多少条路径。

三种情况都是增加一个数组来存放新增的边权或者点权或者最短路径条数，然后修改以上代码的”优化（第三步)"部分。其他地方不用动。

新增边权（假设为花费）


const int maxn = 1010;
const int INF = 0x3fffffff;
int n, g[maxn][maxn], d[maxn];
bool vis[maxn] = { false };
int cost[maxn][maxn], c[maxn];//记录花费
void dijkstra(int s) {
	//1  
	fill(d, d + maxn, INF);
	d[s] = 0;

	//2
	for (int i = 0; i < n; i++) {
		int u = -1, minn = INF;
		for(int j=0;j<n;j++)
			if (vis[j] == false && d[j] < minn) {
				u = j;
				minn = d[j];
			}
		if (u == -1)return;

		//3
		vis[u] = true;
		for (int v = 0; v < n; v++) {
			if (vis[v] == false) {
				if (d[u] + g[u][v] < d[v]) {//第一标尺
					d[v] = d[v] + g[u][v];
					c[v] = c[u] + cost[u][v];
				}
				else if (d[u] + g[u][v] == d[v] && c[u] + cost[u][v] < c[v])//第一标尺相同时，比较第二标尺
					c[v] = c[u] + cost[u][v];
			}
		}
	}
}

新增点权（假设是城市中能收集到的物资）


const int maxn = 1010;
const int INF = 0x3fffffff;
int g[maxn][maxn], n, d[maxn];
bool vis[maxn] = { false };
int weight[maxn];//每个点的权值，输入给出
int w[maxn];//起点到每个点可收集到的最大物资，计算而得

void dijkstra(int s) {
	//1
	fill(d, d + maxn, INF);
	d[s] = 0;

	//2
	for (int i = 0; i < n; i++) {
		int u = -1, minn = INF;
		for(int j=0;j<n;j++)
			if (vis[j] == false && d[j] < minn) {
				u = j;
				minn = d[j];
			}
		if (u == -1)return;

		//3
		vis[u] = true;
		for (int v = 0; v < n; v++) {
			if (vis[v] == false) {
				if (d[u] + g[u][v] < d[v]) {//第一标尺，距离更小，没得说直接更新第一标尺数组和第二标尺数组
					d[v] = d[u] + g[u][v];
					w[v] = w[u] + weight[v];
				}
				else if (d[u] + g[u][v] == d[v] && w[u] + weight[v] > w[v])//第一标尺相同时，若第二标尺更好，则更新第二标尺数组
					w[v] = w[u] + weight[v];
			}
		}
	}
}

求最短路径条数

增加一个数组num[]，令从起点s到达顶点u的最短路径条数为num[u]，初始化时只有num[s]=1，其余为0；

当d[u]+g[u][v]<d[v]时更新d，并让num[v]继承num[u];

而当d[u]+g[u][v]=d[v]时,将num[u]加到num[v]上。

const int maxn = 1010;
const int INF = 0x3fffffff;
int g[maxn][maxn], n, d[maxn];
bool vis[maxn] = { false };
int num[maxn];//起点到每个点的最短路径长度

void dijkstra(int s) {
	//1
	fill(d, d + maxn, INF);
	d[s] = 0;

	//2
	for (int i = 0; i < n; i++) {
		int u = -1, minn = INF;
		for(int j=0;j<n;j++)
			if (vis[j] == false && d[j] < minn) {
				u = j;
				minn = d[j];
			}
		if (u == -1)return;

		//3
		vis[u] = true;
		for (int v = 0; v < n; v++) {
			if (vis[v] == false) {
				if (d[u] + g[u][v] < d[v]) {//最短路径唯一
					d[v] = d[u] + g[u][v];
					num[v] = num[u];
				}
				else if (d[u] + g[u][v] == d[v])//s到v的最短路径多了num[u]个
					num[v] += num[u];
			}
		}
	}
}

先求所有最短路径，然后求第二标尺（dijkstra+dfs）【难】

先在dijkstra算法中记录下所有最短路径（只考虑距离），然后从这些最短路径中选出一条第二标尺最优的路径。

记录所有最短路径，vector<int> pre[MAXN]

const int maxn = 1010;
const int INF = 0x3fffffff;
vector<int> pre[maxn];
int n;
int d[maxn], g[maxn][maxn];
bool vis[maxn] = { false };
void dijstra(int s) {
	//1
	fill(d, d + maxn, INF);
	d[s] = 0;

	//2
	for (int i = 0; i < n; i++) {
		int u = -1, minn = INF;
		for(int j=0;j<n;j++)
			if (vis[j] == false && d[j] < minn) {
				u = j;
				minn = d[j];
			}
		if (u == -1)return;

		//3
		vis[u] = true;
		for (int v = 0; v < n; v++) {
			if (vis[v] == false) {
				if (d[u] + g[u][v] < d[v]) {
					d[v] = d[u] + g[u][v];
					pre[v].clear();//找到更短的路径，则之前的应全部清空
					pre[v].push_back(u);//将这个更短路径上v的前驱，即u，送入pre[v]
				}
				else if (d[u] + g[u][v] == d[v])
					pre[v].push_back(u);//找到一样短的路径，直接把u送入pre[v]
			}
		}
	}
}

遍历所有最短路径找出第二标尺最优的路径

dfs函数

void dfs(int v) {
	if (v == st) {//递归边界，即到达递归树的叶子节点

		//1  当前节点插入，看是否更新答案，又弹出
		temppath.push_back(v);//人为地将起始节点st加入到临时路径，因为在第一步中无法更新起点的pre
		//可能更新答案
		int value = calcu();
		if (value > optvalue) 
			{optvalue = value; anspath = temppath;}
		//当前节点弹出
		temppath.pop_back();//再将起点弹出
		return;
	}

	//未到递归边界时，即递归式
	//2  当前结点插入，看是否有更优前驱，又弹出
	temppath.push_back(v);//将当前结点加入到临时路径后
	for (int i = 0; i < pre[v].size(); i++)
		dfs(pre[v][i]);//递归尝试是否有更优前驱结点
	temppath.pop_back();//已遍历完所有前驱结点，然后将v弹出
}

calcu函数（计算边权或者点权）：


int calcu() {//边权之和
	int value = 0;
	for (int i = temppath.size() - 1; i > 0; --i) {//倒着访问节点
		int id = temppath[i], idnext = temppath[i - 1];
		value += edge_weight[id][idnext];
	}
	return value;
}

int calcu() {//计算点权之和
	int value = 0;
	for (int i = temppath.size() - 1; i > 0; --i)
		value += vertex_weight[temppath[i]];
	return value;
}

模板完整版：

#include <iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<string.h>
using namespace std;
#pragma warning(disable:4996)
#include<string>
#include<stack>
#include<map>
#include<queue>

const int maxn = 1010;
const int INF = 0x3fffffff;
int g[maxn][maxn], n, st, d[maxn];
int vertex_weight[maxn][maxn], edge_weight[maxn];
int optvalue;
bool vis[maxn] = { false };
vector<int> pre[maxn];
vector<int> anspath, temppath;


void dijkstra(int s) {
	//1
	fill(d, d + maxn, INF);
	d[s] = 0;

	//2
	for (int i = 0; i < n; i++) {
		int u = -1, minn = INF;
		for(int j=0;j<n;j++)
			if (vis[u] == false && d[j] < minn) {
				u = j;
				minn = d[j];
			}
		if (u == -1)return;

		//3
		vis[u] = true;
		for (int v = 0; v < n; v++) {
			if (vis[v] == false) {
				if (d[v] < d[u] + g[u][v]) {
					d[v] = d[u] + g[u][v];
					pre[v].clear();
					pre[v].push_back(u);
				}
				else if (d[v] == d[u] + g[u][v])
					pre[v].push_back(u);
			}
		}
	}
}
int calcu() {
	int value = 0;
	for (int i = temppath.size() - 1; i > 0; i--) {
		int id = temppath[i], idnext = temppath[i - 1];
		value += edge_weight[id][idnext];
	}
	return value;
}
void dfs(int v) {
	//边界
	if (v == st) {
		//1.1
		temppath.push_back(v);
		//1.2
		int value = calcu();
		if (value > optvalue) {
			optvalue = value;
			anspath = temppath;
		}
		//1.3
		temppath.pop_back();
		return;
	}

	//递归式
	//2.1
	temppath.push_back(v);
	//2.2
	for (int i = 0; i < pre[v].size(); i++)
		dfs(pre[v][i]);
	//2.3
	temppath.pop_back();
}

 

ur_ytii
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Dijkstra算法求最短路径——Java实现
03-27
Dijkstra算法是图论中的一个经典算法，由荷兰计算机科学家艾兹格·迪科斯彻在1956年提出，用于寻找图中两个节点之间的最短路径。在这个Java实现中，我们将深入探讨如何利用Dijkstra算法来解决最短路径问题。 首先，...
dijkstra算法改进的matlab程序（能求出两点间所有最短路径）
01-20
能求出任意两点间所有最短路径。数模时编写。考虑邻接矩阵中主对角线数据（虽然一般情况都取零）。更具实用性 能求出任意两点间所有最短路径。数模时编写。考虑邻接矩阵中主对角线数据（虽然一般情况都取零）。更具...
Dijkstra算法实现非负权值最短路径的求解(另用小根堆进行优化)
iqRocket的专栏
12-09 2525
利用Dijkstra算法求解非负权值的最小值，基本思想是，进行n-1轮的循环，每一轮都是：求出单边条件下起始结点v0到其他各结点的最短距离，并将邻接到的这个点v1标为“已处理过”，然后再以v1作为中转，找到跟v1距离最近的剩下的顶点v2，接着比较dist[v2]的值和dist[v1]+weight[v1][v2]，如果dist[v2]较大，则将dist[v2]改写为dist[v1]+weight[
HDU 2544 最短路 //Dijkstra 算法 边权必须非负
LMengi000的博客
05-01 359
最短路   Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 81686    Accepted Submission(s): 35376     Problem Description 在每年的校赛里，所有进入决赛的同学都会获...
非负权值有向图上的单源最短路径算法之Dijkstra算法
weixin_30629977的博客
06-26 250
问题的提法是：给定一个没有负权值的有向图和其中一个点src作为源点(source)，求从点src到其余个点的最短路径及路径长度。求解该问题的算法一般为Dijkstra算法。 假设图顶点个数为n，则针对其余n-1个点需要分别找出点src到这n-1个点的最短路径。Dijkstra算法的思想是贪心法，先找出最短的那条路径，其次找到次短的，再找到第三短的，依次类推，直到找完点src到达其...
关于为什么dijkstra算法要求不能有负权边的问题
xingrin的博客
01-18 601
关于为什么dijkstra算法要求不能有负权边的问题
dijkstra--非负权值的单源最短路径STL实现(邻接表+优先队列) (带路径)
qq_40691051的博客
11-26 220
一、预备知识： 用优先队列做大小根堆 注意：是非负权值的单源最短路径的STL实现，权值是负的不能用dijkstra算法， 二、代码： #include<iostream> #include<cstdio> #include<list> #include<queue> #include<set> #define INF 9999999 u...
GIS.rar_GIS路线_dijkstra_gis_所有路径_最佳路径
09-22
Dijkstra算法--c++源代码 基本内容： 1 ）设计一个校园的平面图，所包含的景点不少于十个。以图中顶点表示校内各景点，存放景点名称，代号，简介等信息，以边表示 路径，存放路径长度等相关信息。 2）为来访客人...
最短路径算法——Dijkstra算法参照.pdf
11-07
此外，Dijkstra算法不适用于存在负权边的图，因为负权边可能导致最短路径的更新在算法执行后期才出现。 在实际应用中，Dijkstra算法常与优先队列（如二叉堆）结合，以提高查找最短距离顶点的效率。此外，还有其他...
改进dijkstra算法，寻找两点间所有最短路径 matlab
11-10
两点间所有最短路径寻找 This is an implementation of the dijkstra algorithm, wich finds the minimal cost path between two nodes.
边上值非负的单源最短路径问题----Dijkstra算法
Grady_Ne的博客
01-19 569
问题提出：给定一个带权的有向图（即有向网）G和源点v0，求v0到G中其他每个顶点的最短路径。限定各边上的权值大于0. 算法实现：按路径长度递增的顺序，逐步产生最短路径的算法，即首先求出长度最短的一条最短路径，再参照它求出长度次短的一条最短路径，依次类推，直到从源点v0到其他各顶点的最短路径全部求出为止。 dijkstra具体实现方法如下： 1.设置两个顶点的集合T和S。 (1).S...
带权有向图 - 边上权值非负情形的单源最短路径问题
JaryBlueEye的专栏
06-07 748
1. 问题描述： 给定一个带权有向图D与源点v， 求从v到D中其他顶点的最短路径。限定个边上的权值大于或等于0. 2. java实现： [code="java"]package boke.graph.shortpath1; import java.util.Stack; /** * 问题描述： 给定一个带权有向图D与源点v， 求从v到D中其他顶点的最短路径。限定...
迪杰斯特拉算法详解
a_forever_dream的博客
11-14 1921
介绍 英文名： Dijkstra 用处： 这是个用来在边有非负权的图中求单源最短路的算法。 （注：单源，即只有一个固定的起点） 流程 说白了，就一句话：每次找到离起点最近的点，然后用它到起点的最短路来更新其他的点到起点的最短路，以及，每个点只用一次。 证明和其他的在下面，这里先举个栗子！ 比如说现在有这样一张 555 个点的图（起点是 111）： 下面的 disdisdis 数组表示现在每个点到...
最短路径---Dijkstra算法（单源+边权非负数）
chstor's blog
06-04 497
Dijkstra算法（迪杰斯特拉算法）用来解决单源最短路问题 如果边权出现负数，用SPFA 算法 可以用STL的优先队列priority_queue来优化 Dijkstra伪代码： //G为图，一般设为全局变量，数组d为源点到达各点的最短路径长度，s为起点 Dijkstra(G,d[],s){ 初始化; for(循环n次){ u=使d[u]最小的还未被访问的顶点的标号; 记u已被访问; for(从u出发能到达的所有顶点v){ if(v未被访问&&以u为中介点使s到顶
蓝桥杯 最短路问题 dijkstra算法负权值计算
highlighters的博客
07-24 1028
原题如下： 试题 算法训练 最短路 资源限制 时间限制：1.0s 内存限制：256.0MB 问题描述 给定一个n个顶点，m条边的有向图（其中某些边权可能为负，但保证没有负环）。请你计算从1号点到其他点的最短路（顶点从1到n编号）。 输入格式 第一行两个整数n, m。 接下来的m行，每行有三个整数u, v, l，表示u到v有一条长度为l的边。 输出格式 共n-1行，第i行表示1号点到i+1号点的最短路。 样例输入 3 3 1 2 -1 2 3 -1 3 1 2 样例输出 -1 -2 数据规模与约定 对于1
贪心、图论——单源最短路径Dijkstra算法
Jayphone17的博客
09-28 520
1.问题分析： 单源最短路径问题。给定一个有向带权图G=（V，E），其中每条边的权是非负实数（Dijkstra不支持处理带负权边的）。此外给定V中的一个顶点，成为源点。现在要计算从源点到各顶点的最短路径长度，这里路径长度指路上各边的权之和。 2.算法设计： Dijkstra算法是解决单源最短路径的贪心算法，它求出长度最短的一条路径，再参照最短路径求出长度次短的一条路径，直到求出从源...
Dijkstra 算法（非负边权单源最短路算法）模板
LJR的博客
03-13 569
#include<bits/stdc++.h> #define PII pair <int, int> #define x first #define y second using namespace std; const int N = 1e5+10; priority_queue <PII, vector <PII>, greater <PII> > q; // 小根堆 int idx, w[N<<1], e[N<&lt
贪心算法:单源点最短路径
如是我闻__一时__的博客
05-14 1722
题目描述： 给定带权有向图G =(V,E)，其中每条边的权是非负实数。另外，还给定V中的一个顶点，称为源。现在要计算从源到所有其它各顶点的最短路长度。这里路的长度是指路上各边权之和。这个问题通常称为单源最短路径问题 算法步骤： 代码： /* 问题描述： 给定一个带权有向图G=(V,E)，其中每条边的权都是非负整数。另外，给定V中的一个顶点，作为源。现在计算从源到所有其他各个顶点...
图中两点所有路径_【洛谷日报#242】Johnson 全源最短路径算法学习笔记
weixin_39747334的博客
12-05 198
Johnson 和 Floyd 一样，是一种能求出无负环图上任意两点间最短路径的算法。该算法在 1977 年由 Donald B. Johnson 提出。Part 1 算法概述任意两点间的最短路可以通过枚举起点，跑 次 Bellman-Ford 算法解决，时间复杂度是 的，也可以直接用 Floyd 算法解决，时间复杂度为 。注意到堆优化的 Dijkstra 算法求单源最短路径的时间复杂度比 ...
POJ 2253 ——Frogger——————【最短路、Dijkstra、最长边最小化】
最新发布
05-29
需要注意的是，这道题中跳跃的距离不能超过石头的耗费，因此我们可以将跳跃的距离看作边的权值，求最短路时，可以将边权取相反数，这样Dijkstra算法求出的最短路即为跳跃的耗费之和。 代码实现如下：
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值