在面试中遇到这个问题。想知道有没有更好的解决办法:

给定 N 个任务，以及它们之间的依赖关系，请提供一个执行顺序，确保作业在不违反依赖关系的情况下执行。

示例文件:

5

1<4

3<2

4<5

第一行是任务总数。 1<4 表示任务="" 1="" 必须在任务="" 4="">

一个可能的顺序是: 1 4 5 3 2

我的解决方案使用 DAG 来存储所有数字，然后进行拓扑排序。有没有更简单的方法来解决这个问题？:

    DirectedAcyclicGraph<Integer, DefaultEdge> dag = new DirectedAcyclicGraph<Integer, DefaultEdge>(DefaultEdge.class); 
    Integer [] hm = new Integer[6];
    //Add integer objects to storage array for later edge creation and add vertices to DAG
    for(int x = 1; x <= numVertices; x++){
        Integer newInteger = new Integer(x);
        hm[x] = newInteger;
        dag.addVertex(newInteger);
    }
    for(int x = 1; x < lines.size()-1; x++){
        //Add edges between vertices
        String[] parts = lines.get(x).split("<");
        String firstVertex = parts[0];
        String secondVertex = parts[1];
        dag.addDagEdge(hm[Integer.valueOf(firstVertex)], hm[Integer.valueOf(secondVertex)]);
    }
    //Topological sort
    Iterator<Integer> itr = dag.iterator();
    while(itr.hasNext()){
        System.out.println(itr.next());
    }   

最佳答案

正如几个用户(Gassa、shekhar suman、mhum 和 Colonel Panic)所说，问题是通过找到拓扑排序来解决的。只要 dag 中的迭代器按该顺序返回元素，它就是正确的。 我不知道 DirectedAcyclicGraph 类的来源，所以我无能为力。否则，此方法会按照您的方法进行解析并使用一个简单的算法(实际上，我想到的第一个算法)

public static int[] orderTasks (String[] lines){
    // parse
    int numTasks = Integer.parseInt(lines[0]);
    List<int[]> restrictions = new ArrayList<int[]>(lines.length-1);
    for (int i = 1; i < lines.length; i++){
        String[] strings = lines[i].split("<");
        restrictions.add(new int[]{Integer.parseInt(strings[0]), Integer.parseInt(strings[1])});
    }

    // ordered
    int[] tasks = new int[numTasks];
    int current = 0;

    Set<Integer> left = new HashSet<Integer>(numTasks);
    for (int i = 1; i <= numTasks; i++){
        left.add(i);
    }
    while (current < tasks.length){
        // these numbers can't be written yet
        Set<Integer> currentIteration = new HashSet<Integer>(left);
        for (int[] restriction : restrictions){
            // the second element has at least the first one as precondition
            currentIteration.remove(restriction[1]);
        }
        if (currentIteration.isEmpty()){
            // control for circular dependencies
            throw new IllegalArgumentException("There's circular dependencies");
        }
        for (Integer i : currentIteration){
            tasks[current++]=i;
        }
        // update tasks left
        left.removeAll(currentIteration);
        // update restrictions
        Iterator<int[]> iterator = restrictions.iterator();
        while (iterator.hasNext()){
            if (currentIteration.contains(iterator.next()[0])){
                iterator.remove();
            }
        }
    }
    return tasks;
}

顺便说一句，在你的 hm 数组初始化中，你定义它有 6 个元素。它使 0 位置为空(这不是问题，因为您无论如何都不调用它)但在一般情况下，任务数可能大于 5，然后您将拥有 IndexOutOfBoundsException

另外提一下，在添加边的时候，如果出现循环依赖，DAG抛出的Exception信息如果不够清晰，用户可能会感到困惑。同样，由于我不知道那个类来自哪里，所以我不知道。

关于java - 作业调度算法，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/27573027/