Question

我有一个场景，每个时段都有一个利润和多种工作可供选择。我需要在每个时段选择作业，以获得总体最大利润。我要求获得的最大利润和时间表。

我唯一能想到的就是尝试使用暴力来实现每一项任务。如何有效地解决这个问题。有什么方法可以通过使用特定的算法或数据结构来做得更好吗？

在下面的示例中，可以为timeslot1选择任何作业J1，J2，J4。类似地，对于其他时隙，可以选择任何一个或不选择任何作业。只能为特定时间段选择一个作业。如果作业在一个时隙中完成，则无法再次完成。

EG。如果在TS1中完成j1，则无法在TS2中再次拾取

ExtJS 6

Answer 1

这可以通过weighted maximum matching in bipartite graph以最佳方式解决。

在这里，您的图表为G=(U,V,E)，其中：

U = {1, 2, ...., n} // time slots
V = {J1, J2, ..., J_m} // jobs
E = { (i,J) | if job J can be done in time i }
w(i,J) = profit(i)

通过在时间段J中执行任务i，将上图中的maxmum匹配直接转换为最佳解决方案iff最大匹配节点J与节点i }。

Answer 2

公共类JobProfitMaximizer {

private int numberOfJobs;
private Job[] jobs;
private int maxProfit;

public class JobComparator implements Comparator<Job> {

    @Override
    public int compare(Job arg0, Job arg1) {
        if (arg0.end <= arg1.end)
            return -1;
        else
            return 1;
    }
}

public JobProfitMaximizer() {
    numberOfJobs = 0;
    maxProfit = 0;
}

private void printJobProfiles() {
    for (Job j : jobs) {
        System.out.println(j.start + " " + j.end + " " + j.profit);
    }
}

private void createJobProfiles() {
    jobs = new Job[numberOfJobs];
    File inputFile = new File("***Filepath***********");
    Scanner sc = null;
    int jobCounter = 0;
    try {
        sc = new Scanner(inputFile);
        while (sc.hasNextLine()) {
            String s = sc.nextLine();
            String[] profileOfJob = s.split(" ");
            int start = Integer.parseInt(profileOfJob[1]);
            int end = Integer.parseInt(profileOfJob[2]);
            int profit = Integer.parseInt(profileOfJob[3]);
            jobs[jobCounter] = new Job(start, end, profit);
            jobCounter = jobCounter + 1;
        }
    } catch (FileNotFoundException e) {
        System.out.println("The file is not present");
    } finally {
        try {
            if (sc != null)
                sc.close();
        } catch (Exception f) {
            System.out.println(f.getMessage());
        }
    }
}

private void setNumberOfJobs() {
    File inputFile = new File("***Filepath***********");
    Scanner sc = null;
    int countOfJobs = 0;
    try {
        sc = new Scanner(inputFile);
        while (sc.hasNextLine()) {
            countOfJobs = countOfJobs + 1;
            sc.nextLine();
        }
        numberOfJobs = countOfJobs;
        System.out.println(numberOfJobs);
    } catch (FileNotFoundException e) {
        System.out.println("The file is not present");
    } finally {
        try {
            if (sc != null)
                sc.close();
        } catch (Exception f) {
            System.out.println(f.getMessage());
        }
    }
}

private void sortJobsOnFinishTimes() {
    JobComparator jc = new JobComparator();
    Arrays.sort(jobs, jc);
}

private void calculateMaximumProfit() {
    int[] T = new int[numberOfJobs];
    T[0] = jobs[0].profit;

    for (int i = 1; i < numberOfJobs; i++) {
        T[i] = Math.max(T[i - 1], jobs[i].profit);
        for (int j = i - 1; j >= 0; j--) {
            if (jobs[j].end <= jobs[i].start) {
                T[i] = Math.max(T[i], T[j] + jobs[i].profit);
                break;
            }
        }
    }

    int currentMaxProfitValue = T[0];

    for (int m : T) {
        if (m > currentMaxProfitValue) {
            currentMaxProfitValue = m;
        }
    }
    maxProfit = currentMaxProfitValue;
}

public static void main(String args[]) {
    JobProfitMaximizer j = new JobProfitMaximizer();
    j.setNumberOfJobs();
    j.createJobProfiles();
    j.sortJobsOnFinishTimes();
    j.calculateMaximumProfit();
    System.out.println("The maximum profit is " + j.maxProfit);
}

}

最大化利润，工作安排

2 个答案: