基于稀疏图上的Johnson算法的详解

2016-02-19 10:06 12 1 收藏

只要你有一台电脑或者手机,都能关注图老师为大家精心推荐的基于稀疏图上的Johnson算法的详解,手机电脑控们准备好了吗?一起看过来吧!

【 tulaoshi.com - 编程语言 】

算法步骤简述:

1.计算图G加入新结点后的图G',加入的新结点0到所有原结点之间距离为0,同时形成新的边集E';

2.使用Bellman-Ford算法处理G',并形成0结点到各结点的最小距离d。

3.如果Bellman-Ford算法检测出有负权回路则提示FALSE并退出,否则继续。

4.对所有G'中的顶点v,根据0结点到v的最小距离,将h(v)设置为这个值。

5.对所有的边w(u,v),权值更新为w(u,v)+h(u)-h(v)

6.对图G中所有结点运行Dijkstra算法计算与其他顶点最短距离d'[u][v]

(此处假定G和w集合是分开存储的。直接使用G'也可以,因为0结点对其他结点是不可达的,但这显然浪费了计算时间。如果权值信息存在G'中,可以对G'进行操作,只不过跳过了0结点的处理)

7.原图G中最短距离d[u][v] = d'[u][v] +h(v)-h(u)

  代码中有的地方没有优化,比如辅助结构vassist其实在Bellman-Ford算法和Dijkstra算法两个函数中用法稍微有所不同,而且成员变量在前者中只用了2个;同时松弛算法relax也有类似的情况。前者是简单的复用,后者直接用名字区分。

  代码包含三部分:Bellman-Ford算法、Dijkstra算法、用二项堆实现的优先级数组(Dijkstra算法要用到)。以下是算法的C语言版本,测试实例同《算法导论》图25-1
代码如下:

#include stdio.h
#include stdlib.h

#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:%dn",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 %dn",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;isize;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].dva[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;isize;i++)
        for(j=0;jsize-1;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;jsize;j++)
        printf("to %d: %dn",j,va[j].d);
       

    for(j=0;jsize;j++) {//对0结点不必要
        p = graph[j].adj;
        while(p!=NULL) {
            if(va[p-key].dva[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].dva[i].d)) {
        min = l;
        tmin = va[l].d;
    }
    else {
        min = i;
        tmin = va[i].d;
    }
    if ((r heap_size) &&(va[r].dva[min].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_size1 )
        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;iheap_size;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_newva[i].d)
        return 0;
    va[i].d = key_new;
    while((i0)&&(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;ilen;i++)
        p[i] = U;
    p[s] = 0;
    heap_size = len;

(本文来源于图老师网站,更多请访问http://www.tulaoshi.com/bianchengyuyan/)

    va = initialize_ss(len,s);
    build_min_heap(va,heap_size);//va被拿去建堆,后续输出距离时不能再用了

    while(heap_size0) {
        i = heap_extract_min(va,heap_size);
        printf("node:%dn",i);
        heap_size--;
        for(j=0;jheap_size;j++)
            printf("key:%d,d:%d, in array:%dn",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].dp[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 %dn",i,q-key,q-w);
            q = q-next;
        }
        for(j=0;jheap_size;j++)
            printf("key:%d,d:%d, in array:%dn",va[j].key,va[j].d,p[va[j].key]);
    }
    for(i=0;ilen;i++)
        printf("from %d to %d, distance is %dn",s,i,p[i]);

    free(va);

    for(i=0;ilen;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;in;i++) {
        delta[i]=(int*)malloc(n*sizeof(int));
        d[i]=(int*)malloc(n*sizeof(int));
    }
    for(i=0;in;i++)
        gn[i] = g[i];

    for(i=1;in;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;in;i++) {
        p = gn[i].adj;
        while(p!=NULL) {
            p-w = p-w+h[i]-h[p-key];
            p=p-next;
        }
    }
    for(i=0;in;i++)
        walk(gn,n,i);

    printf("before dijkstran");
    for(i=1;in;i++) {
        dijkstra(gn,n,i,delta);
        for(j=1;jn;j++)
            d[i][j] = delta[i][j] + h[j] - h[i];

    }
    for(i=1;in;i++) {
        for(j=1;jn;j++)
            printf("%dt",d[i][j]);
        printf("n");
    }
    return d;
}

int main(){
    int i,j;
    int **d;
    struct vertex vt[N+1];//为0结点的加入预留位置
    for(i=0;iN+1;i++) {
        vt[i].adj = NULL;
        vt[i].key = i;
    }

(本文来源于图老师网站,更多请访问http://www.tulaoshi.com/bianchengyuyan/)

    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;
}

来源:http://www.tulaoshi.com/n/20160219/1593390.html

延伸阅读
结论:在数据库中研究和实现算法有着相当大的困难,同时也是一种挑战。随着现实世界中业务规则的日益复杂,相应的数据库应用软件实现业务规则需要的算法也日益复杂,把复杂的算法应用在数据库中需要找到一个统一的方式,在熟悉业务规则的前提下,根据数据库的特点和相应的执行命令的能力,找到一种适合数据库批量计算的步骤是解决问题的关...
一、单线程改造为多线程也是个技术活 正如我们看到耗子叔叔博客里写的那样,原来是单线程的应用程序,”后来,我们的程序性能有问题,所以需要变成多线程的,于是,变成多线程后到了线上,发现程序经常占了100%的CPU“。 考虑到是淘宝的工程师曝出来的问题,他们的技术基础一般都很扎实,连他们都用错了,所以把单线程改造为多线程并不是想...
最近项目需要支持表情,表情的添加和解析实现基本上是参照Android自身的SmileyParser,具体就不多讲了, 直接贴上代码: 代码如下: public class SmileyParser { private static SmileyParser sInstance = null; private Context mContext = null; private Pattern mPattern = null; private HashMapString, Integer mSmileyTextToId = nul...
标签: 王者荣耀
1.增加了各段位分别对应胜场数分数的上限值,也就是说更新之后,通过增加胜场数而提升英雄战力值是比较有限的,并且段位越低则上限值越低; 2.每局排位赛的英雄战力值结算规则中,增强了与段位之间的强关联限制,即分数不变的情况下,段位越高则赢了获得的战力值越多,输了扣的越少,段位越低则赢了获得的战力值越少,输了扣的越多;...
有人在Quake III的源代码里面发现这么一段用来求平方根的代码: /*================SquareRootFloat================*/ float SquareRootFloat(float number) {     long i;     float x, y;     const float f = 1.5F;     x = number * 0.5F;     y  = nu...

经验教程

107

收藏

42
微博分享 QQ分享 QQ空间 手机页面 收藏网站 回到头部