优先队列（leetcode239滑动窗口最大值、华为OD机试C卷-执行任务赚积分）

239.滑动窗口最大值

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。
返回 滑动窗口中的最大值 。

int* maxSlidingWindow(int* nums, int numsSize, int k, int* returnSize) {
    int q[numsSize];
    int left=0,right=0;
    for(int i=0;i<k;++i){
        while(left<right&&nums[i]>=nums[q[right-1]])//当前元素大于队尾元素
        right--;//将队尾元素出队直到队尾元素大于当前元素
        q[right++]=i;//元素入栈
    }
    *returnSize=0;
    int* ans=malloc(sizeof(int)*(numsSize-k+1));
    ans[(*returnSize)++]=nums[q[left]];//滑动窗口最大值为队头元素
    for(int i=k;i<numsSize;++i){
        while(left<right&&nums[i]>=nums[q[right-1]])
            right--;
        q[right++]=i;
        while(q[left]<=i-k){
            left++;//左指针和右指针相差k
        }
        ans[(*returnSize)++]=nums[q[left]];//返回队头元素
    }
    return ans;  
}

华为OD机试C卷（100分）-执行任务赚积分

题目描述

现有N个任务需要处理，同一时间只能处理一个任务，处理每个任务所需要的时间固定为1。
每个任务都有最晚处理时间限制和积分值，在最晚处理时间点之前处理完成任务才可获得对应的积分奖励。
可用于处理任务的时间有限，请问在有限的时间内，可获得的最多积分。

输入描述

第一行为一个数 N，表示有 N 个任务
1 ≤ N ≤ 100
第二行为一个数 T，表示可用于处理任务的时间
1 ≤ T ≤ 100
接下来 N 行，每行两个空格分隔的整数（SLA 和 V），SLA 表示任务的最晚处理时间，V 表示任务对应的积分。
1 ≤ SLA ≤ 100
0 ≤ V ≤ 100000

输出描述

可获得的最多积分

用例

输入 4
3
1 2
1 3
1 4
1 5
输出 5
说明 虽然有3个单位的时间用于处理任务，可是所有任务在时刻1之后都无效。
所以在第1个时间单位内，选择处理有5个积分的任务。1-3时无任务处理。
输入 4
3
1 2
1 3
1 4
3 5
输出 9
说明
第1个时间单位内，处理任务3，获得4个积分
第2个时间单位内，处理任务4，获得5个积分
第3个时间单位内，无任务可处理
共获得9个积分

#include <stdio.h>
#include <stdlib.h>
typedef struct{
     int endTime;
     int score;
}WorkOrder;
int cmp(const void *a,const void *b){
     return (*(WorkOrder*)a).score-(*(WorkOrder*)b).score;
}
int getResult(int n,int t,WorkOrder *wos){
     qsort(wos,n,sizeof(WorkOrder),cmp);
     //使用qsort函数和比较函数cmp根据工作订单的分数对wos数组进行排序。
     int ans=0;
     int curTime=0;
     WorkOrder *pq=(WorkOrder*)malloc(t*sizeof(WorkOrder));
     //动态分配内存以创建一个优先级队列pq来存储工作订单。
     int pqSize=0;
     for(int i=0;i<n;i++){//遍历排序后的工作订单数组
          int endTime=wos[i].endTime;
          int score=wos[i].score;
          if(curTime<endTime){//当前时间小于任务最晚完成时间
               pq[pqSize++]=wos[i];//将该工作订单添加到优先级队列pq中,
               ans+=score;//增加答案分数
               curTime++;//增加当前时间
          }else{//当前时间大于或等于工作订单的结束时间
               int min_score=pq[0].score;
               int min_index=0;
               //找到最小积分
               for(int j=1;j<pqSize;j++){
                    if(pq[j].score<min_score){
                         min_score=pq[j].score;
                         min_index=j;
                    }
               }
               if(score>min_score){//检查该工作订单的分数是否大于队列中的最小分数
                    ans+=score-min_score;//如果是,它通过添加工作订单分数与队列最小分数之差来更新答案
                    pq[min_index]=wos[i];
               }
          }
          while(pqSize>t){//检查优先级队列的大小是否超过时间约束t
               int min_score=pq[0].score;
               int min_index=0;
               for(int j=1;j<pqSize;j++){//如果是,它从队列中删除最小分数的工作订单,并相应地调整答案。
                    if(pq[j].score<min_score){
                         min_score=pq[j].score;
                         min_index=j;
                    }
               }

               ans-=pq[min_index].score;
               for(int j=min_index;j<pqSize-1;j++)
                    pq[j]=pq[j+1];
               pqSize--;
          }
     }
     free(pq);
     return ans;
}
int main()
{
    int n,t;
    scanf("%d",&n);
     scanf("%d",&t);
     WorkOrder *wos=(WorkOrder*)malloc(n*sizeof(WorkOrder));
     for(int i=0;i<n;i++)
          scanf("%d %d",&wos[i].endTime,&wos[i].score);
     int res=getResult(n,t,wos);
     printf("%d\n",res);
     free(wos);
    return 0;
}