算法17-无环加权有向图的最短路径算法、优先级限制下的并行任务调度问题的关键路径方法

最新推荐文章于 2023-10-02 16:24:49 发布
最新推荐文章于 2023-10-02 16:24:49 发布
阅读量723 收藏 1
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/meiceatcsdn/article/details/105780056
版权

各位读者，晚上好。

这篇博客继续介绍无环加权有向图方面的内容。里面用到的不少类都有变动，通过附件的方式补充。

本博客代码示例均来自：算法 Algorithmes Forth Edition
[美] Robert Sedgewick Kevin Wayne 著 谢路云译

文章目录

一、环加权有向图的最短路径算法

package com.cmh.algorithm.graph;

import edu.princeton.cs.algs4.Stack;

/**
 * 无环加权有向图的最短路径算法
 * Author:起舞的日子
 * Date:  2020/4/26 下午9:24
 */
public class AcyclicSP {
    private DirectedEdge[] edgeTo;

    private double[] distTo;

    public AcyclicSP(EdgeWeightedDigraph G, int s) {
        edgeTo = new DirectedEdge[G.V()];
        distTo = new double[G.V()];
        for (int v = 0; v < G.V(); v++) {
            distTo[v] = Double.POSITIVE_INFINITY;
        }
        distTo[s] = 0.0;
        Topological top = new Topological(G);
        for (int v : top.order()) {
            relax(G, v);
        }
    }

    /**
     * 顶点的松弛
     */
    private void relax(EdgeWeightedDigraph G, int v) {
        for (DirectedEdge e : G.adj(v)) {
            int w = e.to();
            if (distTo[w] > distTo[v] + e.weight()) {
                distTo[w] = distTo[v] + e.weight();
                edgeTo[w] = e;
            }
        }
    }

    /**
     * 最短路径树(SPT)的标准查询算法
     */
    public double distTo(int v) {
        return distTo[v];
    }

    public boolean hasPathTo(int v) {
        return distTo(v) < Double.POSITIVE_INFINITY;
    }

    public Iterable<DirectedEdge> pathTo(int v) {
        if (!hasPathTo(v)) {
            return null;
        }
        Stack<DirectedEdge> path = new Stack<>();
        for (DirectedEdge e = edgeTo[v]; e != null; e = edgeTo[e.from()]) {
            path.push(e);
        }
        return path;
    }

}

二、优先级限制下的并行任务调度问题的关键路径方法

2.1 最长路径

无环加权有向图中的单点最长路径

package com.cmh.algorithm.graph;

import edu.princeton.cs.algs4.Stack;

/**
 * 无环加权有向图中的单点最长路径
 * Author:起舞的日子
 * Date:  2020/4/26 下午9:24
 */
public class AcyclicLP {
    /**
     * 无环加权有向图中的单点最长路径
     * 给定一副无环加权有向图(边的权重可能为负数)和一个起点s,回答"是否存在一条从s到给定的顶点v的路径?"
     * 如果有，找出最长(总权重最大)的那条路径等类似问题。
     */
    private DirectedEdge[] edgeTo;

    private double[] distTo;

    public AcyclicLP(EdgeWeightedDigraph G, int s) {
        edgeTo = new DirectedEdge[G.V()];
        distTo = new double[G.V()];
        for (int v = 0; v < G.V(); v++) {
            distTo[v] = Double.NEGATIVE_INFINITY;
        }
        distTo[s] = 0.0;
        Topological top = new Topological(G);
        for (int v : top.order()) {
            relax(G, v);
        }
    }

    /**
     * 顶点的松弛
     */
    private void relax(EdgeWeightedDigraph G, int v) {
        for (DirectedEdge e : G.adj(v)) {
            int w = e.to();
            if (distTo[w] < distTo[v] + e.weight()) {
                distTo[w] = distTo[v] + e.weight();
                edgeTo[w] = e;
            }
        }
    }

    /**
     * 最短路径树(SPT)的标准查询算法
     */
    public double distTo(int v) {
        return distTo[v];
    }

    public boolean hasPathTo(int v) {
        return distTo(v) < Double.POSITIVE_INFINITY;
    }

    public Iterable<DirectedEdge> pathTo(int v) {
        if (!hasPathTo(v)) {
            return null;
        }
        Stack<DirectedEdge> path = new Stack<>();
        for (DirectedEdge e = edgeTo[v]; e != null; e = edgeTo[e.from()]) {
            path.push(e);
        }
        return path;
    }

}

2.2 优先级限制下的并行任务调度

package com.cmh.algorithm.graph;

import edu.princeton.cs.algs4.StdIn;
import edu.princeton.cs.algs4.StdOut;

/**
 * 优先级限制下的并行任务调度问题的关键路径方法
 * Author:起舞的日子
 * Date:  2020/4/26 下午11:04
 */
public class CPM {
    public static void main(String[] args) {
        int N = StdIn.readInt();
        StdIn.readLine();
        EdgeWeightedDigraph G;
        G = new EdgeWeightedDigraph(2 * N + 1);
        int s = 2 * N, t = 2 * N + 1;
        for (int i = 0; i < N; i++) {
            String[] a = StdIn.readLine().split("\\s+");
            double duration = Double.parseDouble(a[0]);
            G.addEdge(new DirectedEdge(i, i + N, duration));
            G.addEdge(new DirectedEdge(s, i, 0.0));
            G.addEdge(new DirectedEdge(i + N, t, 0.0));
            for (int j = 1; j < a.length; j++) {
                int successor = Integer.parseInt(a[j]);
                G.addEdge(new DirectedEdge(i + N, successor, 0.0));
            }
        }
        AcyclicLP lp = new AcyclicLP(G, s);
        StdOut.println("Start times:");
        for (int i = 0; i < N; i++) {
            StdOut.printf("%4d : %5.1f\n", i, lp.distTo(i));
        }
        StdOut.printf("Finish time: %5.1f\n", lp.distTo(t));

    }

    /**
     * 这里实现的任务调度问题的关键路径方法将问题规约为：寻找无环加权有向图的最长路径问题
     */
}

三、附件

3.1 Topological 拓扑排序

构造方法有扩展

package com.cmh.algorithm.graph;

import edu.princeton.cs.algs4.StdOut;

/**
 * 拓扑排序
 * Author:起舞的日子
 * Date:  2020/4/25 上午11:48
 */
public class Topological {
    /**
     * 顶点的拓扑排序
     */
    private Iterable<Integer> order;

    public Topological(Digraph G) {
        DirectedCycle cycleFinder = new DirectedCycle(G);
        if (!cycleFinder.hasCycle()) {
            DepthFirstOrder dfs = new DepthFirstOrder(G);
            order = dfs.reversePost();
        }
    }

    public Topological(EdgeWeightedDigraph G) {
        EdgeWeightedDirectedCycle finder = new EdgeWeightedDirectedCycle(G);
        if (!finder.hasCycle()) {
            DepthFirstOrder dfs = new DepthFirstOrder(G);
        }
    }

    public Iterable<Integer> order() {
        return order;
    }

    public boolean isDAG() {
        return order != null;
    }

    public static void main(String[] args) {
        String filename = args[0];
        String separator = args[1];
        SymbolDigraph sg = new SymbolDigraph(filename, separator);
        Topological top = new Topological(sg.G());
        for (int v : top.order) {
            StdOut.println(sg.name(v));
        }

    }
}

3.2 EdgeWeightedDirectedCycle 新增

加权有向图中寻找有向环

package com.cmh.algorithm.graph;

import edu.princeton.cs.algs4.Stack;

/**
 * 加权有向图中寻找有向环
 * Author:起舞的日子
 * Date:  2020/4/26 下午10:10
 */
public class EdgeWeightedDirectedCycle {
    private boolean[] marked;
    private DirectedEdge[] edgeTo;
    private boolean[] onStack;
    private Stack<DirectedEdge> cycle;

    public EdgeWeightedDirectedCycle(EdgeWeightedDigraph G) {
        marked = new boolean[G.V()];
        onStack = new boolean[G.V()];
        edgeTo = new DirectedEdge[G.V()];
        for (int v = 0; v < G.V(); v++) {
            if (!marked[v]) {
                dfs(G, v);
            }
        }
        assert check();
    }

    private void dfs(EdgeWeightedDigraph G, int v) {
        onStack[v] = true;
        marked[v] = true;
        for (DirectedEdge e : G.adj(v)) {
            int w = e.to();
            if (cycle != null) {
                return;
            } else if (!marked[w]) {
                edgeTo[w] = e;
                dfs(G, w);
            } else if (onStack[w]) {
                cycle = new Stack<>();
                DirectedEdge f = e;
                while (f.from() != w) {
                    cycle.push(f);
                    f = edgeTo[f.from()];
                }
                cycle.push(f);
                return;
            }
        }
        onStack[v] = false;
    }

    public boolean hasCycle() {
        return cycle != null;
    }

    public Iterable<DirectedEdge> cycle() {
        return cycle;
    }

    public boolean check() {
        if (hasCycle()) {
            DirectedEdge first = null, last = null;
            for (DirectedEdge e : cycle()) {
                if (first == null) {
                    first = e;
                }
                if (last != null) {
                    if (last.to() != e.from()) {
                        System.err.printf("cycle edges %s and %s not incident\n", last, e);
                        return false;
                    }
                }
                last = e;
            }
            if (last.to() != first.from()) {
                System.err.printf("cycle edges %s and %s not incident\n", last, first);
                return false;
            }
        }
        return true;
    }
}

3.3 DepthFirstOrder 深度优先搜索

构造方法有扩展

package com.cmh.algorithm.graph;

import edu.princeton.cs.algs4.Queue;
import edu.princeton.cs.algs4.Stack;
import edu.princeton.cs.algs4.StdOut;

/**
 * 有向图中基于深度优先搜索的顶点排序
 * Author:起舞的日子
 * Date:  2020/4/25 上午11:40
 */
public class DepthFirstOrder {

    /**
     * 优先级限制下的调度问题等价于 计算有向无环图中的所有顶点的拓扑顺序
     */

    private boolean[] marked;

    private int[] pre;
    private int[] post;
    /**
     * 所有顶点的前序排列
     */
    private Queue<Integer> preorder;

    /**
     * 所有顶点的后续排列
     */
    private Queue<Integer> postorder;

    private int preCounter;

    private int postCounter;

    /**
     * 所有顶点的逆后序排列
     */
    private Stack<Integer> reversePost;

    public DepthFirstOrder(Digraph G) {
        pre = new int[G.V()];
        post = new int[G.V()];
        preorder = new Queue<>();
        postorder = new Queue<>();
        reversePost = new Stack<Integer>();
        marked = new boolean[G.V()];
        for (int v = 0; v < G.V(); v++) {
            if (!marked[v]) {
                dfs(G, v);
            }
        }
        assert check();
    }

    public DepthFirstOrder(EdgeWeightedDigraph G) {
        pre = new int[G.V()];
        post = new int[G.V()];
        preorder = new Queue<>();
        postorder = new Queue<>();
        marked = new boolean[G.V()];
        for (int v = 0; v < G.V(); v++) {
            if (!marked[v]) {
                dfs(G, v);
            }
        }
    }

    private void dfs(Digraph G, int v) {
        preorder.enqueue(v);
        marked[v] = true;
        for (int w : G.adj(v)) {
            if (!marked[w]) {
                dfs(G, w);
            }
        }
        postorder.enqueue(v);
        reversePost.push(v);

    }

    private void dfs(EdgeWeightedDigraph G, int v) {
        marked[v] = true;
        pre[v] = preCounter++;
        preorder.enqueue(v);
        for (DirectedEdge e : G.adj(v)) {
            int w = e.to();
            if (!marked[w]) {
                dfs(G, w);
            }
        }
        postorder.enqueue(v);
        post[v] = postCounter++;
    }

    public int pre(int v) {
        validateVertex(v);
        return pre[v];
    }

    public int post(int v) {
        validateVertex(v);
        return post[v];
    }

    public Iterable<Integer> pre() {
        return preorder;
    }

    public Iterable<Integer> post() {
        return postorder;
    }

    public Iterable<Integer> reversePost() {
        Stack<Integer> reverse = new Stack<>();
        for (int v : postorder) {
            reverse.push(v);
        }
        return reverse;
    }

    private boolean check() {
        int r = 0;
        for (int v : post()) {
            if (post(v) != r) {
                StdOut.println("post(v) and post() inconsistent");
                return false;
            }
            r++;
        }
        r = 0;
        for (int v : pre()) {
            if (pre(v) != r) {
                StdOut.println("pre(v) and pre() inconsistent ");
                return false;
            }
        }
        return true;
    }

    private void validateVertex(int v) {
        int V = marked.length;
        if (v < 0 || v >= V) {
            throw new IllegalArgumentException("vertex " + v + " is not between - and " + (V - 1));
        }
    }

}

四、源码

老地方

https://github.com/cmhhcm/my2020.git

写晕了…

好了，再会。

那起舞的日子
关注
专栏目录
利用有向无环图DAG实现简单的任务依赖调度
秋裤傻的博客
11-07 568
from concurrent.futures import ThreadPoolExecutor from dag import DAG import time class Scheduler: def __init__(self, dag): self.dag = dag def run_dag(self): ...
数据结构与算法--拓补排序及无环加权有向图的最短路径
weixin_30568715的博客
09-27 217
数据结构与算法--拓补排序及无环加权有向图的最短路径 现实生活中一些项目工程、生产开发，都有一个所谓的流程。一个流程分为若干个活动或者说步骤，这些活动具有一个优先级，很显然我们得按照优先级顺序去执行它们（优先级相同的活动可以不强调先后），即某些活动完成之后才能执行下一活动。不能把后期的任务放到前面来做是吧。这可以抽象成有向图，且要求该有向图不能成环。比如你参加校园话剧表演，你总得先写剧本 -&gt...
020无环加权有向图的最短路径实现
m0_37692918的博客
02-10 315
无环加权有向图的最短路径实现图学习笔记索引本文参考《算法(第4版)》1.依赖类2.无环加权有向图的最短路径 图学习笔记索引 001自定义输入流In类实现 002背包数据类型Bag实现 003无向图数据类型实现 004基于图的深度优先搜索 005使用深度优先搜索找图中的所有连通分量 005-1基于深度优先搜索查找图中连通路径 006基于深度优先搜索判断图中是否存在环 007基于深度优先搜索判断一个无...
无环加权有向图最短路径算法证明
zhangxiaojiakele的博客
03-18 363
接上文 本文讲解一类特殊的图无环加权有向图最短路径搜索算法. 我们知道, 对于有向无环图, 可以使用拓扑排序对节点进行排序, 使得对于图中的任意有向边v−>wv->wv−>w, 排序后均有顶点w出现在顶点v之后.因此, 对于无环加权有向图这类特殊的图类型,我们可以利用其可拓扑排序的性质设计最短路径搜索算法, 具体如下: 使用distTo[]数组保存起点sss至其他顶点的路径长度...
【算法】python实现优先级限制下的并行任务调度问题的关键路径算法CPM
qq_32643313的博客
09-05 941
# -*- coding: utf-8 -*- # /usr/bin/python # 作者：kimicr # 实验日期：20190827 # Python版本：3.6.3 ''' 问题描述： “并行任务调度”，给定一组需要完成的任务和每个任务所需要的时间，以及一组关于 任务完成的先后次序的优先级限制。在满足限制条件的前提条件下，该如何在若干相同处理 器上安排任务并在最短的时间内完成所有任...
"IAAS云计算环境下多目标任务调度的混沌松鼠搜索算法（CSSA）研究总结
工程科学与技术，国际期刊23（2020）891完整文章IAAS云计算环境下多目标任务调度的混沌松鼠搜索算法（CSSA）M.S. Sanaja，P.M.Joe Prathapba印度泰米尔纳德邦，钦奈，Satyabhama大学计算机科学与工程系b印度泰米尔...
linux进程调度算法-CFS
m0_74282605的博客
03-21 360
使用这个原则，CFS 尝试对所有任务公平，并且总是尝试让系统为每个进程提供零等待时间——每个进程都拥有相等的 CPU 份额（“理想的、精确的、多任务的 CPU”会做到这一点） ）。使用这个原则，CFS 尝试对所有任务公平，并且总是尝试让系统为每个进程提供零等待时间——每个进程都拥有相等的 CPU 份额（“理想的、精确的、多任务的 CPU”会做到这一点） ）。“理想的、精确的、多任务的 CPU”是一种硬件 CPU，它可以同时（并行）运行多个进程，为每个进程提供平等的处理器能力（不是时间，而是能力）。
数据结构与算法–关键路径
36大数据
09-30 819
作者：sunhaiyu 关键路径与无环加权有向图的最长路径 现在考虑一个这样的问题：你今天事情比较多，要洗衣服、做作业还要烧水洗澡，之后出去找朋友玩。假设洗衣服要20分钟，烧水要30分钟，做作业的话你把朋友做好的带回来抄，只需要10分钟。你想能早些去找朋友，但在那之前又必须将那些事做完，你要怎么安排呢？很容易想到，这三者同时进行：打好水开始烧水，衣服扔进洗衣机，回书桌抄作业…2
一文带你弄懂linux进程调度算法--CFS
lqycwr的博客
01-10 2778
多进程学了这么久，该不会还不知道linux 操作系统是如何进行进程调度的吧？
图的结构建立与最短路径算法
12-01
简单介绍图的结构建立与最短路径算法，不是源代码
数据结构；最小生成树；最短路径；关键路径
12-08
1、 对无向图求每个顶点的度，或对有向图求每个顶点的入度和出度（2、 完成插入顶点和边（或弧）的功能3、 完成删除顶点和边（或弧）的功能 4、 两种存储结构的转换，如果其中一种存储结构为十字链表或邻接多重表则增加 5、 输出图的深度优先遍历序列或广度优先遍历序列（6、 求图的深度优先或广度优先的生成树（或生成森林）（存储结构为孩子-兄弟链表），并对生成树进行遍历（7、 判断图的连通性，输出连通分量的个数8、 判断图中是否存在环，无向图 9、 给出顶点u和v，判断u到v是否存在路径 10、求顶点u到v的一条简单路径 11、求顶点u到v的所有简单路径 12、求顶点u到v的最短路径 13、求顶点u到其余各顶点的最短路径 14、求任两个顶点之间的最短路径 15、求最小生成树 16、对于有一个源点和一个汇点的有向网，求关键路径
有向无环图调度任务框架airflow安装部署测试
FREEDOM
06-19 611
安装最新版 pip3 install apache-airflow==1.10.10 先初始化 airflow initdb 此时会在当前用户的根目录下生成一个airflow目录，如root用户下的 /root/airflow 可以使用find / -name airflow.cfg查询位置。 此时使用的sqllite数据库 修改为使用mysql库 Airflow的配置文件airflow.cfg配置 再次初始化 airflow initdb 可看到 ...
5.五环加权有向图-最短路径问题
danteshenqu的博客
09-23 555
特点： 1）五环 2）比Dijktra更快，能够在线性时间内解决单点最短路径问题 3）能够处理负权重的边 4）还能够找出最长路径
7-34 任务调度的合理性（拓扑排序 判断有向无环图）
勿忘勿失的博客
03-24 556
题目链接：7-34 任务调度的合理性 考查知识：拓扑排序 判断有向无环图 题意描述： “任务调度”包括一组子任务、以及每个子任务可以执行所依赖的子任务集。 对n个任务，判断是否可进行“调度” 思路简析： 拓扑排序模板题了 具体代码#include<bits/stdc++.h> using namespace std; typedef long long ll; const int N=1e3; int n,k,x,in[N];//点的入度 vector<int>G[N.
图功能的实现C++（最短路径，关键路径，拓扑排序，关节点，~~~~~~~~~~等等）
chenjian_0704的专栏
10-13 3144
先按照注释的提示新建三个头文件Graph,Lqueue,stack，把相应头文件的实现代码分别拷进去，最后在源程序中包含这三个头文件。在main()函数中调用各种功能时（比如求关键路径），先实例化一个模板的对象，如Graph gph;接下来要调用创建图的函数（共有三种存储结构：邻接矩阵的，邻接表的，十字链表的－－－可根据单词缩写判断是哪个函数）例如要求关键路径，需先创建一个以邻接表作存
算法第四版 P426 无环加权有向图最短路径算法实现
Pandamentle的博客
12-27 680
本算法为处理无环加权有向图的算法，需要用到最短路径以及拓扑排序，所以，在图中不能存在有向环，否则数据错误，本算法的拓扑排序理论来自于之前的Kosaraju算法，即通过反图的拓扑排序顺序来遍历原图中的所有节点，因为不用判断节点是否被访问，所以不需要布尔数组判断点是否可用。 这里要特别指出书中的一个错误，P427顶端的第一幅图上方的拓扑排序的顺序应为：5，1，3，6，4，0，7，2 本算法由四个类
启动优化之有向无环图任务管理二
最新发布
zhuhai0613的博客
10-02 155
启动优化之有向无环图任务管理
图：关键路径和最短路径
weixin_36049506的博客
03-09 2796
文章目录关键路径最短路径 关键路径 顶点是事件i和事件j，边的权值是活动所需的时间 例子： 第一步：确定哪些活动是关键活动（最早开始时间等于最晚开始时间） 第二步：确定哪些路径是关键路径（关键活动构造的路径） 最短路径 因为v6无法到达v5，所以v1到v5的最短路径就是21。 将每一顶点当作源点，依次调用迪杰斯特拉算法，同样可以得到每一对顶点之间的最短路径，事...
贪心算法求解最优问题：从多段图最短路径到经典案例分析
例如，多段图的最短路径问题，动态规划通过逐步计算子问题的最优解来找到全局最优。 贪心算法的特点在于它不是基于全面的枚举，而是从前向后，根据当前情况做出“贪心”决策，逐步逼近最终解。例如，在多段图的最短...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值