给定工作流程的拓扑排序

Question

I am trying to solve a question in order to find the topological sorting. Here is the question:

We want to write a function to separate a given workflow's steps into multiple stages in such a way that all the steps in each individual stage can run at the same time. The function should return a list of lists, in which each list represents one stage. Each step should run in the earliest possible stage.

input =  [
   ["clean", "build"],
   ["metadata", "binary"],
   ["build", "link"],
   ["link", "binary"],
   ["clean", "metadata"],
   ["build", "resources"]
   ]
output = [
   ["clean"],
   ["build", "metadata"],
   ["resources", "link"],
   ["binary"]
   ]

Here is the code that I have written:

public class Solution {

public static List<List<String>> createWorkflowStages(List<List<String>> precursorSteps){

    //main logic
    return new ArrayList<>();
}

static List<Test> tests = Arrays.asList(
new Test(
"build stages",
Arrays.asList(
    Arrays.asList("clean", "build"),
    Arrays.asList("metadata", "binary"),
    Arrays.asList("build", "link"),
    Arrays.asList("link", "binary"),
    Arrays.asList("build", "resources")
),
Arrays.asList(
    Arrays.asList("clean"),
    Arrays.asList("build", "metadata"),
    Arrays.asList("resources", "link"),
    Arrays.asList("binary")
    )),
new Test(
"making dinner",

Arrays.asList(
    Arrays.asList("boil", "serve"),
    Arrays.asList("chop", "boil"),
    Arrays.asList("stir", "boil"),
    Arrays.asList("set table", "serve")
    ),
Arrays.asList(
    Arrays.asList("chop", "stir", "set table"),
    Arrays.asList("boil"),
    Arrays.asList("serve")
)
)
);

public static class Test{
    public String name;
    public List<List<String>> input;
    public List<List<String>> expectedOutput;

    public Test(String name, List<List<String>> input, List<List<String>> expectedOutput){
        this.name = name;
        this.input = input;
        this.expectedOutput = expectedOutput;
    }
}

private static boolean equalOutputs(List<List<String>> a, List<List<String>> b){
    if(a == null || b == null || a.size() != b.size()){
        return false;
    }
    for(int i = 0; i<a.size(); i++){
        List<String> a1 = new ArrayList<>(a.get(i));
        List<String> b1 = new ArrayList<>(b.get(i));
        a1.sort(null);
        b1.sort(null);
        if(!a1.equals(b1)){
            return false;
        }
    }
    return true;
}

public static void main(String[] args) {
    int passed = 0;
    for(Test test : tests){
        System.out.printf("==> Testing %s...\n", test.name);
        try{
            List<List<String>> actualOutput = createWorkflowStages(test.input);
            if(equalOutputs(actualOutput, test.expectedOutput)){
                System.out.println("PASS");
                passed++;
            }else{
                System.out.println("FAIL");
                System.out.printf("Input: %s\n", test.input);
                System.out.printf("Expected Output: %s\n", test.expectedOutput);
                System.out.printf("Actual Output: %s\n", actualOutput);
            }
        }catch(Exception e){
            System.out.println("FAIL");
            System.out.println(e);
        }
    }
    System.out.printf("==> Passed %d of %d tests\n", passed, tests.size());
}

}

I am stuck in createWorkflowStages method. What should be the efficient way to solve this question? thanks

Answer 1

You are looking at a special case of project management problem, the Critical Path Problem , but in your case all the tasks are of equal duration. You can find many implementations on the Web, for example this one , in which you have a method CalculateEarliestStartDate .

Note that you have to have a graph structure that is much more adapted that what you propose with your lists, in order to have an effective algorithm.