算法 Bellman-Ford及其队列优化

屏幕快照 2018-04-27 下午4.08.22.png

/*
Bellman-Ford 思想:对每一条边进行松弛操作(dis[v[i]]>dis[u[i]]+w[i])。共进行(n-1)轮,每进行一轮松弛操作,相当于扩充了一些新的边
当进行完k轮时,就已经找到从源点发出“最多经过k条边”到达各个顶点的最短路。n个顶点,最短路径上最多有n-1条边
如果进行n-1轮,还可以对边进行松弛成功,则此图一定存在负权回路~

负权回路:即回路权值之和为负

以此题而言:第一轮松弛操作后,dis[3]=inf(无穷大),但第二轮后dis[3] =-1; 是因为在第一轮后dis[2]=2;
dis[3] = dis[2]+2->3; 即dis[3] = dis[1]+1->2 + 2—>3;所以每一轮都相当于扩充了一些新边。
当进行完k轮时,就已经找到从源点发出“最多经过k条边”到达各个顶点的最短路

*/

#pragma mark - - Bellman-Ford 算法
-(void)test1 {
    
    // 存储边数据 例如:{2,3,2} 表示顶点2到顶点3的权值为2
    // e[0][3] 没有任何意义,只是为了让边的遍历从1开始
    int e[6][3] = {{0,0,0},{2,3,2},{1,2,-3},{1,5,5},{4,5,2},{3,4,3}};
    
    // u[6] v[5] w[5] 分别存储两个顶点和权值
    int u[6];
    int v[6];
    int w[6];
    for (int i=1; i<=5; i++) {
        u[i] = e[i][0];
        v[i] = e[i][1];
        w[i] = e[i][2];
    }
    
    int n=5;  // 顶点数
    int m=5; // 边数
    int inf=9999; // 表示∞
    // dis[6] 存储源点到其他顶点的权值
    int dis[6];
    for (int i=0; i<=n; i++) {
        dis[i] =inf;
    }
    
    // 设置源点为顶点1
    dis[1] =0;
    
    
    // 共进行n-1轮
    for (int k=1; k<=n-1; k++) {
        // 对边进行松弛操作
        for (int i=1; i<=m; i++) {
            if (dis[v[i]] > dis[u[i]] + w[i]) {
                dis[v[i]] = dis[u[i]] +w[i];
            }
        }
    }
    
    // 判断是否负权回路
    int flag=0;
    for (int i=1; i<=m; i++) {
        if (dis[v[i]] > dis[u[i]] + w[i]) {
            flag=1;
        }
    }
   
    if (flag==1) {
        printf("该图存在回路\n");
    }else {
        // 打印数据
        for (int i=1; i<=n; i++) {
            printf("%4d",dis[i]);
        }
        printf("\n");
    }
    
}

// 对上述算法进行优化
/*
在实际操作中,有时只进行了K轮(k<n-1),dis[]数组就不再发生变化,所以我们可以根据dis[]的变化来提前
退出循环

*/

-(void)test2 {
    // 存储边数据 例如:{2,3,2} 表示顶点2到顶点3的权值为2
    // e[0][3] 没有任何意义,只是为了让边的遍历从1开始
    int e[6][3] = {{0,0,0},{2,3,2},{1,2,-3},{1,5,5},{4,5,2},{3,4,3}};
    int n=5; // 顶点数
    int m=5; // 边数
    // u[] v[] w[] 分别存储顶点和权值
    int u[6];
    int v[6];
    int w[6];
    for (int i=1; i<=m; i++) {
        u[i] =e[i][0];
        v[i] =e[i][1];
        w[i] =e[i][2];
    }
    
    int dis[6]; // 存储源点到各个顶点的最短距离
    int inf=9999; // 表示无穷大
    
    for (int i=0; i<=n; i++) {
        dis[i] = inf;
    }
    
    // 设置源点为顶点1
    dis[1] =0;
    
    // 进行n-1轮
    for (int k=1; k<=n-1; k++) {
        // 检查是否松弛成功
        int check =0;
        // 对每一条边进行松弛操作
        for (int i=1; i<=m; i++) {
            if (dis[v[i]] > dis[u[i]] + w[i]) {
                dis[v[i]] = dis[u[i]] + w[i];
                check =1;
            }
        }
        
        if (check==0) {
            // check=0 表示当前这一轮 dis[] 没有变化,那么再进行一轮也不会有变化
            // 提前退出循环
            break ;
        }
    }
    
    // 判断是否存在负权回路
    int flag=0;
    for (int i=1; i<=m; i++) {
        if (dis[v[i]] > dis[u[i]] + w[i]) {
            flag =1;
        }
    }
    
    if (flag==1) {
        printf("该图存在回路\n");
    }else {
        // 打印数据
        for (int i=1; i<=n; i++) {
            printf("%4d",dis[i]);
        }
        printf("\n");
    }
    
    
}

/*
当对边进行松弛操作后,某些顶点的最短距离dis[k]已经固定下来,在后面的对边的松弛操作中,这个dis[k]
不会发生变化。如果dis[u[i]] 固定下来了,那么对顶点u[i]的所有边做松弛操作都不会有效果(dis[v[i]] = dis[u[i]] + w[i])。所以仅对最短路程发生变化的顶点的相邻边进行松弛操作~
/
/

Bellman—Ford的队列优化:每次仅对最短路程发生变化的点的相邻边进行松弛操作。即对一个顶点的所有边进行
松弛操作,如果dis[v[i]] > dis[u[i]] + w[i],则将dis[v[i]] 加入队列中,循环队列(head++)~

*/

#pragma mark - - Bellman-Ford的队列优化

-(void)test3 {
    // 存储边数据 例如:{2,3,2} 表示顶点2到顶点3的权值为2
    // e[0][3] 没有任何意义,只是为了让边的遍历从1开始
    int e[6][3] = {{0,0,0},{2,3,2},{1,2,-3},{1,5,5},{4,5,2},{3,4,3}};
    int n=5;
    int m=5;
    // 邻接表
    // first[i] 存储顶点i的第一条边的编号
    int first[6];
    // next[i] 存储边i的下一条边的编号
    int next[6];
    
    // 初始化first[]
    for (int i=0; i<=m; i++) {
        first[i] = -1;
    }
    
    // u[] v[] w[] 分别存储顶点和权值
    int u[6];
    int v[6];
    int w[6];
    // 邻接表 赋值
    for (int i=1; i<=m; i++) {
        u[i] = e[i][0];
        v[i] = e[i][1];
        w[i] = e[i][2];
        
        // 邻接表 核心代码
        next[i] =first[u[i]];
        first[u[i]] = i;
    }
    
    // 初始化 dis[]
    int dis[6];
    int inf = 9999;
    for (int i=0; i<=5; i++) {
        dis[i] = inf;
    }
    
    // 初始化 队列
    int que[10];
    int head=1;
    int tail=1;
    // 初始化标记数组(标记队列里的点)
    int book[10]= {0};
    
    // 源点1赋值
    // 赋值dis[]
    dis[1]=0;
    // 入队
    que[tail] = 1;
    tail ++;
    // 标记
    book[1] =1;
    
    
    // 核心代码
    // 循环队列
    // 如果存在负权回路,队列会一直执行
    int sum=0; // 记录松弛操作次数
    int flag=0; // 标记是否存在负权回路
    while (head<tail) {
        // 获取队首顶点t
        int t =que[head];
        // 获取顶点t的第一条边
        int k = first[t];
        // 获取顶点t的所有出边
        while (k!=-1) {
            sum++;
            // 对边进行松弛
            if (dis[v[k]] > dis[u[k]] + w[k]) {
                // 松弛成功
                dis[v[k]] = dis[u[k]] + w[k];
                // book[] 数组用来判断当前点是否在队列里
                if (book[v[k]] == 0) {
                    // 标记
                    book[v[k]] = 1;
                    // 入队
                    que[tail] = v[k];
                    tail++;
                }
               
            }
            // 下一条边
            k = next[k];
            
        }
        
        // 出队
        /*
         当一个顶点的最短路程变短后,需要对这个顶点的所有边进行松弛操作,但是如果这个顶点的最短路程
         再次变小,需要再次对这个顶点的所有边进行松弛操作~
         */
        book[que[head]] = 0; //把出队的点重新标记为0
        head ++ ; // head++ 才能继续执行队列里的其他点
        
        // 当图不存在负权回路时,最多会进行n*m次松弛操作
        // 如果sum(松弛操作次数)>n*m+1 ,那一定存在负权回路
        // 为什么是n*m,Bellman-Ford 算法最多执行(n-1)*m次就可以使源点到各个顶点的距离达到最小值
        if (sum>n*m+1) {
            flag =1;
            break ;
        }
        
    }
    
    
    // 打印
    if (flag==1) {
        printf("该图存在回路\n");
    }else {
        // 打印数据
        for (int i=1; i<=n; i++) {
            printf("%4d",dis[i]);
        }
        printf("\n");
    }
    
    
}

推荐阅读更多精彩内容

  • 本文将介绍三种常见的最短路算法:Dijkstra,Floyd,SPFA Dijkstra Dijkstra是有向图...
    maxkibble阅读 1,150评论 0 0
  • 参见贪心算法——最短路径Dijkstra算法参见动态规划 目录 0.最短路径问题0.1 最短路径问题描述 0.1....
    王侦阅读 3,473评论 1 9
  • 在讲Bellman-Ford之前先介绍另一种存储图的方法:邻接表。 邻接表 先上数据,以下是一个包含4个顶点,5条...
    我系哆啦阅读 537评论 1 8
  • 微信 很多人做微商认为技巧方法很重要,其实思维比技巧更重要。 我总是会遇到很多微商新人,大家总喜欢问,怎样才能做好...
    独一无二LGZ阅读 615评论 0 3
  • 英语版教程http://v.youku.com/v_show/id_XMTQyNjU0ODg0.html 国语版h...
    剑山阅读 6,397评论 2 51
  • 看着我妹的毕业照,觉得青春真好! 想着自己近来的照片,似乎多了份内敛和成熟。时光的刀不停地雕刻,慢慢把我们磨成了苍...
    小么么哒阅读 106评论 1 1
  • 清辉倾泻,繁星微醒 子夜无眠 一杯空寂饮尽 孤影孑然 冷巷无行人 钟摆敲打时光,不停 念着千年不变的圣经 攀爬时间...
    山上人家123阅读 157评论 10 21