我们首先来看一下什么是前向星.

 

前向星是一种特殊的边集数组,我们把边集数组中的每一条边按照起点从小到大排序,如果起点相同就按照终点从小到大排序,

并记录下以某个点为起点的所有边在数组中的起始位置和存储长度,那么前向星就构造好了.

 

用len[i]来记录所有以i为起点的边在数组中的存储长度.

用head[i]记录以i为边集在数组中的第一个存储位置.

 

那么对于下图:

 


 

 

我们输入边的顺序为:

 

1 2

2 3

3 4

1 3

4 1

1 5

4 5

 

那么排完序后就得到:

 

编号:     1      2      3      4      5      6      7

起点u:    1      1      1      2      3      4      4

终点v:    2      3      5      3      4      1      5

 

得到:

 

head[1] = 1    len[1] = 3

head[2] = 4    len[2] = 1

head[3] = 5    len[3] = 1

head[4] = 6    len[4] = 2

 

但是利用前向星会有排序操作,如果用快排时间至少为O(nlog(n))

 

 

如果用链式前向星,就可以避免排序.

 

我们建立边结构体为:

 

struct Edge
{
int next;
int to;
int w;
};

 

其中edge[i].to表示第i条边的终点,edge[i].next表示与第i条边同起点的下一条边的存储位置,edge[i].w为边权值.

 

另外还有一个数组head[],它是用来表示以i为起点的第一条边存储的位置,实际上你会发现这里的第一条边存储的位置其实

在以i为起点的所有边的最后输入的那个编号.

 

head[]数组一般初始化为-1,对于加边的add函数是这样的:

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

 初始化cnt = 0,这样,现在我们还是按照上面的图和输入来模拟一下:

 

edge[0].to = 2;     edge[0].next = -1;      head[1] = 0;

edge[1].to = 3;     edge[1].next = -1;      head[2] = 1;

edge[2].to = 4;     edge[2],next = -1;      head[3] = 2;

edge[3].to = 3;     edge[3].next = 0;       head[1] = 3;

edge[4].to = 1;     edge[4].next = -1;      head[4] = 4;

edge[5].to = 5;     edge[5].next = 3;       head[1] = 5;

edge[6].to = 5;     edge[6].next = 4;       head[4] = 6;

 

很明显,head[i]保存的是以i为起点的所有边中编号最大的那个,而把这个当作顶点i的第一条起始边的位置.

 

这样在遍历时是倒着遍历的,也就是说与输入顺序是相反的,不过这样不影响结果的正确性.

比如以上图为例,以节点1为起点的边有3条,它们的编号分别是0,3,5   而head[1] = 5

 

我们在遍历以u节点为起始位置的所有边的时候是这样的:

 

for(int i=head[u];~i;i=edge[i].next)

 

那么就是说先遍历编号为5的边,也就是head[1],然后就是edge[5].next,也就是编号3的边,然后继续edge[3].next,也

就是编号0的边,可以看出是逆序的.

模板代码1:

 1 #include <cstdio>
2 #include <cstring>
3 #include <algorithm>
4 #include <queue>
5 using namespace std;
6 const int inf = 0x3f3f3f3f;
7 const int M = 4444;
8 int d[M],head[M],vis[M];
9 struct nod{
10 int nex,to,w;
11 }eg[M];
12 typedef pair<int,int> P;
13 int cnt=0;
14 inline void add(int u,int v,int w){
15 eg[cnt].to=v;
16 eg[cnt].w=w;
17 eg[cnt].nex=head[u];
18 head[u]=cnt++;
19 }
20 void dijkstra(int s){
21 priority_queue<P,vector<P>,greater<P> >que;
22
23 d[s]=0;
24 que.push(P(0,s));
25 while(!que.empty()){
26 P p = que.top();
27 que.pop();
28 int v=p.second;
29 if(d[v]<p.first) continue;
30 for(int i=head[v];~i;i=eg[i].nex){
31 nod e=eg[i];
32 if(e.w+d[v]<d[e.to]){
33 d[e.to]=e.w+d[v];
34 que.push(P(d[e.to],e.to));
35 }
36 }
37 }
38 }
39 int main(){
40 int t,n;
41 scanf("%d %d",&t,&n);
42 memset(d,inf,sizeof(d));
43 memset(head,-1,sizeof(head));
44 for(int i=0;i<t;i++){
45 int u,v,cost;
46 scanf("%d %d %d",&u,&v,&cost);
47 add(u,v,cost);
48 add(v,u,cost);
49 }
50 dijkstra(1);
51 printf("%d\n",d[n]);
52 return 0;
53 }

 转自:http://blog.csdn.net/acdreamers/article/details/16902023

      http://blog.csdn.net/henuwhr/article/details/76668590

      

p.p1 { margin: 0; font: 18px Menlo; color: rgba(201, 27, 19, 1) }
p.p2 { margin: 0; font: 18px Menlo; color: rgba(130, 46, 14, 1) }
p.p3 { margin: 0; font: 18px Menlo; color: rgba(195, 34, 117, 1) }
p.p4 { margin: 0; font: 18px Menlo }
p.p5 { margin: 0; font: 18px Menlo; color: rgba(4, 53, 255, 1) }
p.p6 { margin: 0; font: 18px Menlo; color: rgba(97, 34, 174, 1) }
span.s1 { font-variant-ligatures: no-common-ligatures; color: rgba(130, 46, 14, 1) }
span.s2 { font-variant-ligatures: no-common-ligatures }
span.s3 { font-variant-ligatures: no-common-ligatures; color: rgba(201, 27, 19, 1) }
span.s4 { font-variant-ligatures: no-common-ligatures; color: rgba(4, 53, 255, 1) }
span.s5 { font-variant-ligatures: no-common-ligatures; color: rgba(0, 0, 0, 1) }
span.s6 { font-variant-ligatures: no-common-ligatures; color: rgba(112, 61, 170, 1) }
span.s7 { font-variant-ligatures: no-common-ligatures; color: rgba(97, 34, 174, 1) }
span.s8 { font-variant-ligatures: no-common-ligatures; color: rgba(195, 34, 117, 1) }
span.s9 { font-variant-ligatures: no-common-ligatures; color: rgba(83, 154, 164, 1) }
span.s10 { font-variant-ligatures: no-common-ligatures; color: rgba(61, 29, 129, 1) }
p.p1 { margin: 0; font: 18px Menlo; color: rgba(201, 27, 19, 1) }
p.p2 { margin: 0; font: 18px Menlo; color: rgba(130, 46, 14, 1) }
p.p3 { margin: 0; font: 18px Menlo; color: rgba(195, 34, 117, 1) }
p.p4 { margin: 0; font: 18px Menlo }
p.p5 { margin: 0; font: 18px Menlo; color: rgba(4, 53, 255, 1) }
p.p6 { margin: 0; font: 18px Menlo; color: rgba(97, 34, 174, 1) }
span.s1 { font-variant-ligatures: no-common-ligatures; color: rgba(130, 46, 14, 1) }
span.s2 { font-variant-ligatures: no-common-ligatures }
span.s3 { font-variant-ligatures: no-common-ligatures; color: rgba(201, 27, 19, 1) }
span.s4 { font-variant-ligatures: no-common-ligatures; color: rgba(4, 53, 255, 1) }
span.s5 { font-variant-ligatures: no-common-ligatures; color: rgba(0, 0, 0, 1) }
span.s6 { font-variant-ligatures: no-common-ligatures; color: rgba(112, 61, 170, 1) }
span.s7 { font-variant-ligatures: no-common-ligatures; color: rgba(97, 34, 174, 1) }
span.s8 { font-variant-ligatures: no-common-ligatures; color: rgba(195, 34, 117, 1) }
span.s9 { font-variant-ligatures: no-common-ligatures; color: rgba(83, 154, 164, 1) }
span.s10 { font-variant-ligatures: no-common-ligatures; color: rgba(61, 29, 129, 1) }

模板 Dijkstra+链式前向星+堆优化(非原创)的更多相关文章

  1. 【最短路】Dijkstra+ 链式前向星+ 堆优化(优先队列)

    Dijkstra+ 链式前向星+ 优先队列   Dijkstra算法 Dijkstra最短路算法,个人理解其本质就是一种广度优先搜索.先将所有点的最短距离Dis[ ]都刷新成∞(涂成黑色),然后从起点 ...

  2. HDU 2544最短路 【dijkstra 链式前向星+优先队列优化】

    最开始学最短路的时候只会用map二维数组存图,那个时候还不知道这就是矩阵存图,也不懂得效率怎么样 经过几个月的历练再回头看最短路的题, 发现图可以用链式前向星来存, 链式前向星的效率是比较高的.对于查 ...

  3. 【模板】链式前向星+spfa

    洛谷传送门--分糖果 博客--链式前向星 团队中一道题,数据很大,只能用链式前向星存储,spfa求单源最短路. 可做模板. #include <cstdio> #include <q ...

  4. 单元最短路径算法模板汇总(Dijkstra, BF,SPFA),附链式前向星模板

    一:dijkstra算法时间复杂度,用优先级队列优化的话,O((M+N)logN)求单源最短路径,要求所有边的权值非负.若图中出现权值为负的边,Dijkstra算法就会失效,求出的最短路径就可能是错的 ...

  5. 洛谷P3371单源最短路径Dijkstra版(链式前向星处理)

    首先讲解一下链式前向星是什么.简单的来说就是用一个数组(用结构体来表示多个量)来存一张图,每一条边的出结点的编号都指向这条边同一出结点的另一个编号(怎么这么的绕) 如下面的程序就是存链式前向星.(不用 ...

  6. Floyd && Dijkstra +邻接表 +链式前向星(真题讲解来源:城市路)

    1381:城市路(Dijkstra) 时间限制: 1000 ms         内存限制: 65536 KB提交数: 4066     通过数: 1163 [题目描述] 罗老师被邀请参加一个舞会,是 ...

  7. 三种邻接表存图模板:vector邻接表、数组邻接表、链式前向星

    vector邻接表: ; struct Edge{ int u,v,w; Edge(int _u=0,int _v=0,int _w=0){u=_u,v=_v,w=_w;} }; vector< ...

  8. 网络流dinic模板,邻接矩阵+链式前向星

    //这个是邻接矩阵的#include<iostream> #include<queue> #include<string.h> #include<stdio. ...

  9. 链式前向星版DIjistra POJ 2387

    链式前向星 在做图论题的时候,偶然碰到了一个数据量很大的题目,用vector的邻接表直接超时,上网查了一下发现这道题数据很大,vector可定会超的,不会指针链表的我找到了链式前向星这个好东西,接下来 ...

随机推荐

  1. CMU数据库(15-445)Lab0-环境搭建

    0.写在前面 从这篇文章开始.开一个新坑,记录以下自己做cmu数据库实验的过程,同时会分析一下除了要求我们实现的代码之外的实验自带的一些代码.争取能够对实现一个数据库比较了解.也希望能写进简历.让自己 ...

  2. Sentry(v20.12.1) K8S 云原生架构探索,JavaScript 性能监控之采样 Transactions

    系列 Sentry-Go SDK 中文实践指南 一起来刷 Sentry For Go 官方文档之 Enriching Events Snuba:Sentry 新的搜索基础设施(基于 ClickHous ...

  3. pandas高级操作

    pandas高级操作 import numpy as np import pandas as pd from pandas import DataFrame,Series 替换操作 替换操作可以同步作 ...

  4. 炸裂!MySQL 82 张图带你飞

    之前两篇文章带你了解了 MySQL 的基础语法和 MySQL 的进阶内容,那么这篇文章我们来了解一下 MySQL 中的高级内容. 其他文章: 138 张图带你 MySQL 入门 47 张图带你 MyS ...

  5. 小麦苗数据库巡检脚本,支持Oracle、MySQL、SQL Server和PG等数据库

    目录 一.巡检脚本简介 二.巡检脚本特点 三.巡检结果展示 1.Oracle数据库 2.MySQL数据库 3.SQL Server数据库 4.PG数据库 5.OS信息 四.脚本运行方式 1.Oracl ...

  6. mysql8.0.19忘记密码

    1.管理员打开cmd窗口 2.输入net stop mysql,停止mysql服务 3.开启跳过验证密码的mysql服务 用记事本打开 输入skip-grant-tables ,保存 4.管理员打开新 ...

  7. PostgreSQL创建只读权限的用户

    1.创建只读角色 CREATE ROLE readaccess; 2.授予对现有表的访问权限 GRANT USAGE ON SCHEMA public TO readaccess; GRANT SEL ...

  8. BFS DFS与回溯

    https://blog.csdn.net/u014303647/article/details/88328526 cyc: https://github.com/CyC2018/CS-Notes/b ...

  9. nginx 配置文件解读

    参考:链接 在微服务的体系之下,Nginx正在被越来越多的项目采用作为网关来使用,配合 Lua 做限流.熔断等控制 --源自 nginx Lua 脚本语言,用标准C语言编写并以源代码形式开放, 其设计 ...

  10. Java——入门“HelloWorld”

    //Java程序的结构 //下面这个:外层框架 public class HellloWorld { // Java入口程序框架 //类名与文件名完全一样 public static void mai ...