给定一个作业数组,其中每个作业都有一个截止期限,如果作业在截止期限之前完成,则可获得相关利润。此外,每个作业都占用一个单位时间,因此任何作业的最小可能截止期限都是 1。如果一次只能安排一项作业,则最大化总利润。
例子:
输入:四个工作,截止日期和利润如下
JobID 截止期限 利润
一 4 20
二 1 10
三 1 40
四 1 30
输出:以下是工作利润最大的序列:c、a
输入: 五项工作,截止日期和利润如下
JobID 截止期限 利润
a 2 100
b 1 19
c 2 27
d 1 25
e 3 15
输出:以下是工作利润最大的序列:c,a,e
朴素方法:要解决问题,请遵循以下想法:
生成给定作业集的所有子集,并检查各个子集是否可行。跟踪所有可行子集中的最大利润。
作业排序问题的贪婪方法:
贪婪地首先选择利润最高的工作,方法是按利润降序对工作进行排序。这将有助于最大化总利润,因为为每个时间段选择利润最高的工作最终将最大化总利润
按照给定的步骤解决问题:
按利润的降序对所有工作进行排序。
按利润递减的顺序对工作进行迭代。对于每项工作,执行以下操作:
找到一个时间段 i,使得时间段为空、i < 截止时间且 i 最大。将作业放入
此时间段并将此时间段标记为已填充。
如果不存在这样的 i,则忽略该工作。
下面是上述方法的实现:
// C program for the above approach
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
// A structure to represent a job
typedef struct Job {
char id; // Job Id
int dead; // Deadline of job
int profit; // Profit if job is over before or on
// deadline
} Job;
// This function is used for sorting all jobs according to
// profit
int compare(const void* a, const void* b)
{
Job* temp1 = (Job*)a;
Job* temp2 = (Job*)b;
return (temp2->profit - temp1->profit);
}
// Find minimum between two numbers.
int min(int num1, int num2)
{
return (num1 > num2) ? num2 : num1;
}
// Returns maximum profit from jobs
void printJobScheduling(Job arr[], int n)
{
// Sort all jobs according to decreasing order of profit
qsort(arr, n, sizeof(Job), compare);
int result[n]; // To store result (Sequence of jobs)
bool slot[n]; // To keep track of free time slots
// Initialize all slots to be free
for (int i = 0; i < n; i++)
slot[i] = false;
// Iterate through all given jobs
for (int i = 0; i < n; i++) {
// Find a free slot for this job (Note that we start
// from the last possible slot)
for (int j = min(n, arr[i].dead) - 1; j >= 0; j--) {
// Free slot found
if (slot[j] == false) {
result[j] = i; // Add this job to result
slot[j] = true; // Make this slot occupied
break;
}
}
}
// Print the result
for (int i = 0; i < n; i++)
if (slot[i])
printf("%c ", arr[result[i]].id);
}
// Driver's code
int main()
{
Job arr[] = { { 'a', 2, 100 },
{ 'b', 1, 19 },
{ 'c', 2, 27 },
{ 'd', 1, 25 },
{ 'e', 3, 15 } };
int n = sizeof(arr) / sizeof(arr[0]);
printf(
"Following is maximum profit sequence of jobs \n");
// Function call
printJobScheduling(arr, n);
return 0;
}
// This code is contributed by Aditya Kumar (adityakumar129)
输出
以下是工作的最大利润序列
c a e
计算机辅助设计
时间复杂度: O(N 2 )
辅助空间: O(N)
使用优先级队列(最大堆)的作业排序问题:
按截止日期的升序对作业进行排序,然后从末尾开始迭代,计算每两个连续截止日期之间的可用时隙。当空时隙可用且堆不为空时,将作业的利润包含在最大堆的根部,因为这有助于为每组可用时隙选择利润最大的作业。
以下是按照步骤进行的示例代码:
#include <stdio.h>
#include <stdlib.h>
// 定义作业结构体
typedef struct {
int id; // 作业 ID
int deadline; // 截止日期
int profit; // 利润
} Job;
// 最大堆的结构体定义
typedef struct {
Job* arr; // 存储作业的数组
int capacity; // 最大容量
int size; // 当前大小
} MaxHeap;
// 交换两个作业的函数
void swap(Job* a, Job* b) {
Job temp = *a;
*a = *b;
*b = temp;
}
// 最大堆的比较函数
int maxHeapCompare(Job a, Job b) {
return a.profit - b.profit;
}
// 最大堆的堆化操作
void maxHeapify(MaxHeap* maxHeap, int parent) {
int largest = parent;
int left = 2 * parent + 1;
int right = 2 * parent + 2;
if (left < maxHeap->size && maxHeapCompare(maxHeap->arr[left], maxHeap->arr[largest]) > 0) {
largest = left;
}
if (right < maxHeap->size && maxHeapCompare(maxHeap->arr[right], maxHeap->arr[largest]) > 0) {
largest = right;
}
if (largest != parent) {
swap(&(maxHeap->arr[parent]), &(maxHeap->arr[largest]));
maxHeapify(maxHeap, largest);
}
}
// 创建最大堆
MaxHeap* createMaxHeap(int capacity) {
MaxHeap* maxHeap = (MaxHeap*)malloc(sizeof(MaxHeap));
maxHeap->capacity = capacity;
maxHeap->size = 0;
maxHeap->arr = (Job*)malloc(capacity * sizeof(Job));
return maxHeap;
}
// 插入作业到最大堆
void insertJob(MaxHeap* maxHeap, Job job) {
if (maxHeap->size == maxHeap->capacity) {
return;
}
maxHeap->arr[maxHeap->size] = job;
int i = maxHeap->size;
maxHeap->size++;
while (i > 0 && maxHeapCompare(maxHeap->arr[i], maxHeap->arr[(i - 1) / 2]) > 0) {
swap(&(maxHeap->arr[i]), &(maxHeap->arr[(i - 1) / 2]));
i = (i - 1) / 2;
}
}
// 从最大堆中获取具有最大利润和截止日期的作业
Job getMaxJob(MaxHeap* maxHeap) {
return maxHeap->arr[0];
}
// 从最大堆中移除具有最大利润和截止日期的作业
void extractMaxJob(MaxHeap* maxHeap) {
if (maxHeap->size == 0) {
return;
}
maxHeap->arr[0] = maxHeap->arr[maxHeap->size - 1];
maxHeap->size--;
maxHeapify(maxHeap, 0);
}
// 快速排序比较函数
int compare(const void* a, const void* b) {
return ((Job*)a)->deadline - ((Job*)b)->deadline;
}
int main() {
// 示例数据
Job jobs[] = { {1, 2, 100}, {2, 1, 19}, {3, 2, 27}, {4, 1, 25}, {5, 3, 15} };
int numJobs = sizeof(jobs) / sizeof(jobs[0]);
// 根据截止日期排序
qsort(jobs, numJobs, sizeof(Job), compare);
// 创建最大堆
MaxHeap* maxHeap = createMaxHeap(numJobs);
int currentTime = jobs[numJobs - 1].deadline;
int resultSize = 0;
Job result[numJobs];
for (int i = numJobs - 1; i >= 0; i--) {
while (currentTime > 0 && maxHeap->size > 0) {
Job maxJob = getMaxJob(maxHeap);
if (maxJob.deadline >= currentTime) {
result[resultSize++] = maxJob;
currentTime--;
}
extractMaxJob(maxHeap);
}
if (currentTime == 0) {
break;
}
insertJob(maxHeap, jobs[i]);
}
// 根据截止日期对结果数组进行排序
qsort(result, resultSize, sizeof(Job), compare);
// 输出结果
printf("优化后的作业顺序: \n");
for (int i = 0; i < resultSize; i++) {
printf("作业ID: %d, 利润: %d, 截止日期: %d\n", result[i].id, result[i].profit, result[i].deadline);
}
// 释放内存
free(maxHeap->arr);
free(maxHeap);
return 0;
}
以上只是一个简单的示例实现,实际应用中可能需要根据具体问题进一步优化和完善。
输出
以上示例是工作的最大利润序列
时间复杂度: O(N log N)
辅助空间: O(N)