Java/src/main/java/com/thealgorithms/dynamicprogramming/OptimalJobScheduling.java

package com.thealgorithms.dynamicprogramming;

/**
 * This class refers to the Optimal Job Scheduling problem with the following constrains:
 *  - precedence relation between the processes
 *  - machine pair dependent transportation delays
 *
 * https://en.wikipedia.org/wiki/Optimal_job_scheduling
 *
 * @author georgioct@csd.auth.gr
 */
public class OptimalJobScheduling {

    private final int numberProcesses;
    private final int numberMachines;
    private final int[][] run;
    private final int[][] transfer;
    private final int[][] cost;

    /**
     * Constructor of the class.
     * @param numberProcesses ,refers to the number of precedent processes(N)
     * @param numberMachines ,refers to the number of different machines in our disposal(M)
     * @param run , N*M matrix refers to the cost of running each process to each machine
     * @param transfer ,M*M symmetric matrix refers to the transportation delay for each pair of
     *     machines
     */
    public OptimalJobScheduling(int numberProcesses, int numberMachines, int[][] run, int[][] transfer) {
        this.numberProcesses = numberProcesses;
        this.numberMachines = numberMachines;
        this.run = run;
        this.transfer = transfer;
        this.cost = new int[numberProcesses][numberMachines];
    }

    /**
     * Function which computes the cost of process scheduling to a number of VMs.
     */
    public void execute() {
        this.calculateCost();
        this.showResults();
    }

    /**
     * Function which computes the cost of running each Process to each and every Machine
     */
    private void calculateCost() {

        for (int i = 0; i < numberProcesses; i++) { // for each Process

            for (int j = 0; j < numberMachines; j++) { // for each Machine

                cost[i][j] = runningCost(i, j);
            }
        }
    }

    /**
     * Function which returns the minimum cost of running a certain Process to a certain Machine.In
     * order for the Machine to execute the Process ,he requires the output of the previously
     * executed Process, which may have been executed to the same Machine or some other.If the
     * previous Process has been executed to another Machine,we have to transfer her result, which
     * means extra cost for transferring the data from one Machine to another(if the previous
     * Process has been executed to the same Machine, there is no transport cost).
     *
     * @param process ,refers to the Process
     * @param machine ,refers to the Machine
     * @return the minimum cost of executing the process to the certain machine.
     */
    private int runningCost(int process, int machine) {

        if (process == 0) { // refers to the first process,which does not require for a previous one
            // to have been executed
            return run[process][machine];
        } else {

            int[] runningCosts = new int[numberMachines]; // stores the costs of executing our Process depending on
            // the Machine the previous one was executed

            for (int k = 0; k < numberMachines; k++) { // computes the cost of executing the previous
                // process to each and every Machine
                runningCosts[k] = cost[process - 1][k] + transfer[k][machine] + run[process][machine]; // transferring the result to our Machine and executing
                // the Process to our Machine
            }
            return findMin(runningCosts); // returns the minimum running cost
        }
    }

    /**
     * Function used in order to return the minimum Cost.
     * @param costArr ,an Array of size M which refers to the costs of executing a Process to each
     *     Machine
     * @return the minimum cost
     */
    private int findMin(int[] costArr) {

        int min = 0;

        for (int i = 1; i < costArr.length; i++) {

            if (costArr[i] < costArr[min]) {
                min = i;
            }
        }
        return costArr[min];
    }

    /**
     * Method used in order to present the overall costs.
     */
    private void showResults() {

        for (int i = 0; i < numberProcesses; i++) {

            for (int j = 0; j < numberMachines; j++) {
                System.out.print(cost[i][j]);
                System.out.print(" ");
            }

            System.out.println();
        }
        System.out.println();
    }

    /**
     * Getter for the running Cost of i process on j machine.
     */
    public int getCost(int process, int machine) {
        return cost[process][machine];
    }
}