c语言 工作排序（Job Sequencing Problem）

        给定一个作业数组，其中每个作业都有一个截止期限，如果作业在截止期限之前完成，则可获得相关利润。此外，每个作业都占用一个单位时间，因此任何作业的最小可能截止期限都是 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)