C语言编程johnson算法,基于稀疏图上的Johnson算法的详解
#include
#include
#define U 65535
#define PARENT(i) ((i-1)/2)
#define LEFT(i) (2*(i)+1)
#define RIGHT(i) (2*(i)+2)
#define N 5
struct vertex {
int key;
struct vtable *adj;
};
struct vtable {
int key;//这个key是在vertex数组的序号
//struct vertext *v;
int w;
struct vtable *next;
};
struct vassist {
int d;
int p;
int key;
};
int insert(struct vertex *,int,int,int,int);
int walk(struct vertex *,int,int);
struct vassist *initialize_ss(int,int);
int relaxd(int *,int ,int ,int);
int relaxb(struct vassist *,int ,int ,int);
int build_min_heap(struct vassist *,int);
int min_heapify(struct vassist *, int ,int);
int heap_extract_min(struct vassist *,int);
int inheap(struct vassist *,int ,int );
int heap_decrease(struct vassist *,int ,int);
int dijkstra(struct vertex *,int,int,int **);
int bellman_ford(struct vertex *,int*, int,int);
int insert(struct vertex *p,int len,int i,int j,int w) {
struct vtable *q,*prev;
q = p[i].adj;
printf("key:%d\n",p[i].key);
prev = NULL;
while(q!=NULL) {
if (q->key == j) {
printf("error: v %d to %d already exist.\n",i,j);
return 0;
}
else {
prev = q;
q=q->next;
}
}
q = (struct vtable*)malloc(sizeof(struct vtable));
q->key = j;
q->w = w;
q->next = NULL;
if(prev!=NULL)
prev->next = q;
else
p[i].adj = q;
return 1;
}
int walk(struct vertex *p,int len,int i) {
struct vtable *q = p[i].adj;
while(q!=NULL) {
printf(" %d,w is %d\n",q->key,q->w);
q=q->next;
}
printf("\n");
}
struct vassist *initialize_ss(int size,int s) {
int i;
struct vassist *va;
va = (struct vassist *)malloc(size*sizeof(struct vassist));
for(i=0;i
va[i].key = i;//建堆后i!=key
va[i].d = U;
va[i].p = -1;
}
va[s].d = 0;
return va;
}
//relax for dijkstra
int relaxd(int *p,int u,int v,int w) {//w=w(u,v)
if(p[v]>p[u]+w) {
p[v] = p[u]+w;
//为了简单处理,p使用的是数组
//没有父母标记
//如果想用父母标记,请将p改为一个自定义的结构体
}
return 1;
}
//relax for beltman_ford
int relaxb(struct vassist *va,int u,int v,int w) {//w=w(u,v)
if(va[v].d>va[u].d+w) {
va[v].d = va[u].d+w;
va[v].p = u;
}
return 1;
}
int bellman_ford(struct vertex *graph,int *h,int size,int s) {//算法要求不含源点可达的负权回路
int i,j;
struct vtable *p;
struct vassist *va;
va = initialize_ss(size,s);
for(i=1;i
for(j=0;j
p = graph[j].adj;
while(p!=NULL) {
relaxb(va,j,p->key,p->w);
p=p->next;
}
}
printf("from %d,\n",s);
for(j=0;j
printf("to %d: %d\n",j,va[j].d);
for(j=0;j
p = graph[j].adj;
while(p!=NULL) {
if(va[p->key].d>va[j].d+p->w)
return 0;
p = p->next;
}
}
for(j=1;j<=size;j++)
h[j] = va[j].d;
free(va);
h[0] = 0;
return 1;
}
int build_min_heap(struct vassist *va,int size) {//建堆
int i;
for (i =size/2-1; i>=0; i--)
min_heapify(va,i,size);
return 1;
}
int min_heapify(struct vassist *va, int i,int heap_size) {
int l,r,min;
struct vassist temp;
int tmin = U;
l = LEFT(i);
r = RIGHT(i);
if ((l < heap_size) &&(va[l].d
min = l;
tmin = va[l].d;
}
else {
min = i;
tmin = va[i].d;
}
if ((r < heap_size) &&(va[r].d
min = r;
tmin = va[r].d;
}
if (!(min == i)) {
temp.d = va[min].d;
temp.p = va[min].p;
temp.key = va[min].key;
va[min].d = va[i].d;
va[min].p = va[i].p;
va[min].key = va[i].key;
va[i].d = temp.d;
va[i].p = temp.p;
va[i].key = temp.key;
min_heapify(va,min,heap_size);
}
return 1;
}
int heap_extract_min(struct vassist *va,int heap_size) {
int min;
if ( heap_size<1 )
return -1;
min = va[0].key;
va[0].p = va[heap_size -1].p;
va[0].d = va[heap_size -1].d;
va[0].key = va[heap_size -1].key;
heap_size = heap_size -1;
min_heapify(va,0,heap_size);
return min;
}
int inheap(struct vassist *va,int heap_size,int j) {
int i;
for(i=0;i
if(va[i].key == j)
return i;
return -1;
}
int heap_decrease(struct vassist *va,int i,int key_new) {
struct vassist temp;
if(key_new>va[i].d)
return 0;
va[i].d = key_new;
while((i>0)&&(va[PARENT(i)].d > va[i].d)) {
temp.d = va[i].d;
temp.p = va[i].p;
temp.key = va[i].key;
va[i].d = va[PARENT(i)].d;
va[i].p = va[PARENT(i)].p;
va[i].key = va[PARENT(i)].key;
va[PARENT(i)].d = temp.d;
va[PARENT(i)].p = temp.p;
va[PARENT(i)].key = temp.key;
i = PARENT(i);
}
return 1;
}
int dijkstra(struct vertex *graph,int len,int s,int **delta) {
int i,j,heap_size;
struct vtable *q;
struct vassist *va;
int *p;
p = (int *)malloc(len * sizeof(int));
for(i=0;i
p[i] = U;
p[s] = 0;
heap_size = len;
va = initialize_ss(len,s);
build_min_heap(va,heap_size);//va被拿去建堆,后续输出距离时不能再用了
while(heap_size>0) {
i = heap_extract_min(va,heap_size);
printf("node:%d\n",i);
heap_size--;
for(j=0;j
printf("key:%d,d:%d, in array:%d\n",va[j].key,va[j].d,p[va[j].key]);
q = graph[i].adj;
while(q!=NULL) {
j=inheap(va,heap_size,q->key);
if(j>=0)
if(va[j].d>p[i]+q->w)
heap_decrease(va,j,p[i]+q->w);
relaxd(p,i,q->key,q->w);//其实可以合并heap_decreas和relax,不过为了接口简单没有这样做
printf("relax %d to %d ,w is %d\n",i,q->key,q->w);
q = q->next;
}
for(j=0;j
printf("key:%d,d:%d, in array:%d\n",va[j].key,va[j].d,p[va[j].key]);
}
for(i=0;i
printf("from %d to %d, distance is %d\n",s,i,p[i]);
free(va);
for(i=0;i
delta[s][i] = p[i];
}
free(p);
}
int **johnson(struct vertex *g, int n) {
int i,j;
int *h,**delta,**d;
struct vertex *gn;
struct vtable *p;
gn = (struct vertex *)malloc(n*sizeof(struct vertex));
h = (int *)malloc(n*sizeof(int));
delta = (int**)malloc(n*sizeof(int *));
d = (int**)malloc(n*sizeof(int *));
for(i=0;i
delta[i]=(int*)malloc(n*sizeof(int));
d[i]=(int*)malloc(n*sizeof(int));
}
for(i=0;i
gn[i] = g[i];
for(i=1;i
insert(gn,n,0,i,0);
if(!bellman_ford(gn,h,n,0)) {
printf("the input graph contains a negative-weight cycle.\n");
return NULL;
}
for(i=0;i
p = gn[i].adj;
while(p!=NULL) {
p->w = p->w+h[i]-h[p->key];
p=p->next;
}
}
for(i=0;i
walk(gn,n,i);
printf("before dijkstra\n");
for(i=1;i
dijkstra(gn,n,i,delta);
for(j=1;j
d[i][j] = delta[i][j] + h[j] - h[i];
}
for(i=1;i
for(j=1;j
printf("%d\t",d[i][j]);
printf("\n");
}
return d;
}
int main(){
int i,j;
int **d;
struct vertex vt[N+1];//为0结点的加入预留位置
for(i=0;i
vt[i].adj = NULL;
vt[i].key = i;
}
insert(vt,N+1,1,2,3);
insert(vt,N+1,1,3,8);
insert(vt,N+1,1,5,-4);
insert(vt,N+1,2,4,1);
insert(vt,N+1,2,5,7);
insert(vt,N+1,3,2,4);
insert(vt,N+1,4,3,-5);
insert(vt,N+1,4,1,2);
insert(vt,N+1,5,4,6);
d = johnson(vt,N+1);
return 1;
}
C语言编程johnson算法,基于稀疏图上的Johnson算法的详解相关推荐
- 单片机c语言编程编码器数值,基于单片机的光电编码器测速报告详解.doc
课程设计报告 课程名称: 微机原理课程设计 题 目: 基于51单片机的光电编码器测速 摘要 光电编码器是高精度位置控制系统常用的一种位移检测传感器.在位置控制系统中,由于电机既可能正转,也可能反转,所 ...
- c语言编程步骤Vision4,【2017年整理】keil_μVision4使用详解教程.pdf
[2017年整理]keil_μVision4使用详解教程 Keil μVision4 使用详解 zxmh6 前言 单片机开发中除必要的硬件外,同样离不开软件,我们写的汇编语言源程序要变为 CPU 可以 ...
- 用c语言编写篮球过程运行结果,基于单片机的篮球计时计分器设计(c语言编程、含proteus仿真图) 本科毕业论文.doc...
基于单片机的篮球计时计分器设计(c语言编程.含proteus仿真图) 本科毕业论文 摘要 单片机,亦称单片微电脑或单片微型计算机.它是把中央处理器(CPU).随机存取存储器(RAM).只读存储器(RO ...
- 《C语言编程魔法书:基于C11标准》——1.3 主流C语言编译器介绍
本节书摘来自华章计算机<C语言编程魔法书:基于C11标准>一书中的第1章,第1.3节,作者: 陈轶 更多章节内容可以访问云栖社区"华章计算机"公众号查看. 1.3 主流 ...
- 《C语言编程魔法书:基于C11标准》——2.6 大端与小端
本节书摘来自华章计算机<C语言编程魔法书:基于C11标准>一书中的第2章,第2.6节,作者: 陈轶 更多章节内容可以访问云栖社区"华章计算机"公众号查看. 2.6 大端 ...
- 《C语言编程魔法书:基于C11标准》——第一篇 预备知识篇 第1章 C魔法概览1.1 例说编程语言...
本节书摘来自华章计算机<C语言编程魔法书:基于C11标准>一书中的第1章,第1.1节,作者: 陈轶 更多章节内容可以访问云栖社区"华章计算机"公众号查看. 第一篇 预备 ...
- c语言魔法书,C语言编程魔法书:基于C11标准
C语言编程魔法书:基于C11标准 作者:陈轶 著 出版日期:2017年05月 文件大小:10.29M 支持设备: ¥60.00在线试读 适用客户端: 言商书局 iPad/iPhone客户端:下载 An ...
- c语言程序设计资料书下载,C语言编程魔法书:基于C11标准 (陈轶著) 完整pdf高清版[20MB]...
C语言编程魔法书:基于C11标准主要讲解C11标准的语法内容,并且从整个编译.连接到加载过程都会涉及.同时在后会分别介绍GCC编译器与Clang编译器的C语言语法扩展.通过阅读本书,读者能够完全掌握新 ...
- 《C语言编程魔法书:基于C11标准》——2.9 本章小结
本节书摘来自华章计算机<C语言编程魔法书:基于C11标准>一书中的第2章,第2.9节,作者: 陈轶 更多章节内容可以访问云栖社区"华章计算机"公众号查看. 2.9 本章 ...
最新文章
- php多表头表格,HTML多表头表格代码示例
- oracle中的listener.ora和tnsnames.ora
- mysql对数据库的备份和还原
- 如何在 GPU 上加速数据科学
- HDU 6703 array(主席树 + set)
- string最大容量_string初步使用
- 大型Lambda的C# 泊松累积分布
- 中国计算机学会推荐国际学术会议和期刊目录(2015 年)
- linux下载安装花生壳
- 单片机c语言程序编写歌谱,单片机简谱程序
- C++ intptr_t类型
- java华氏度xhuan_华氏摄氏转换
- egg extend ts_NAS初体验—威联通TS-451D - jingkunliu
- 小块渲染VS渐进式渲染
- 7 HomePlug AV 中央协调器CCo
- 33学习笔记——描述统计分析3--数据的描述统计量
- 解决番茄插件visual assist x 不能安装的问题
- 百度地图 - 绘制驾车路线图
- tensorflow.keras入门1
- 关于 SecureFx传输远程服务器中文显示乱码 的解决方法
热门文章
- EBImage中文文档
- Codeforces C. Andrew and Stones
- Invista跟销售的面试
- Acquire and Release Semantics
- 黑马Linux笔记05【Linux系统软件安装,MySQL、Tomcat、Nginx、RabbitMQ、Redis、ElasticSearch、Zookeeper】
- 李弘毅机器学习笔记:第十章:Keras2.0
- Supplier JAVA_使用Supplier Java 8进行缓存
- 微分先行PID控制算法
- koa实战 (一):项目搭建
- Windows linux 敏感目录 路径汇总