CodeForces - 853A - Planning（C++ 优先队列）

#CodeForces - 853A - Planning
Helen works in Metropolis airport. She is responsible for creating a departure schedule. There are n flights that must depart today, the i-th of them is planned to depart at the i-th minute of the day.

Metropolis airport is the main transport hub of Metropolia, so it is difficult to keep the schedule intact. This is exactly the case today: because of technical issues, no flights were able to depart during the first k minutes of the day, so now the new departure schedule must be created.

All n scheduled flights must now depart at different minutes between (k + 1)-th and (k + n)-th, inclusive. However, it’s not mandatory for the flights to depart in the same order they were initially scheduled to do so — their order in the new schedule can be different. There is only one restriction: no flight is allowed to depart earlier than it was supposed to depart in the initial schedule.

Helen knows that each minute of delay of the i-th flight costs airport ci burles. Help her find the order for flights to depart in the new schedule that minimizes the total cost for the airport.

Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 300 000), here n is the number of flights, and k is the number of minutes in the beginning of the day that the flights did not depart.

The second line contains n integers c1, c2, …, cn (1 ≤ ci ≤ 107), here ci is the cost of delaying the i-th flight for one minute.

Output
The first line must contain the minimum possible total cost of delaying the flights.

The second line must contain n different integers t1, t2, …, tn (k + 1 ≤ ti ≤ k + n), here ti is the minute when the i-th flight must depart. If there are several optimal schedules, print any of them.

Example
Input
5 2
4 2 1 10 2
Output
20
3 6 7 4 5
Note
Let us consider sample test. If Helen just moves all flights 2 minutes later preserving the order, the total cost of delaying the flights would be (3 - 1)·4 + (4 - 2)·2 + (5 - 3)·1 + (6 - 4)·10 + (7 - 5)·2 = 38 burles.

However, the better schedule is shown in the sample answer, its cost is (3 - 1)·4 + (6 - 2)·2 + (7 - 3)·1 + (4 - 4)·10 + (5 - 5)·2 = 20 burles.
题目链接

题意是有n架飞机，然后前k架晚点了，然后要把晚点的每一架飞机都还要起飞，而且每一架飞机都不能比之前提前，每一架飞机迟到都有损失，题目告诉每架飞机迟到单位时间的损失，让你对他们重新排序，使得损失最小。

这个题目的思路就是，现将前面已经迟到的飞机进行排序，入队，然后损失最大的先出队，与前面没迟到的的进行替换以让损失降到最低。这样的话，用优先队列就可以了。

#include<iostream>
#include<cstdio>
#include<queue>
using namespace std;

struct plane
{
    int x;    //记录该编号飞机迟到1分钟的损失
    int num;    //记录飞机编号
    bool operator < (const plane & obj) const
    {
        return x < obj.x;
    }
}a[300010];
int ans[300030];
long long result=0;

int main()
{
    int n,k;
    scanf("%d%d",&n,&k);
    for(int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i].x);
        a[i].num = i;
    }
    priority_queue<plane> q;    //这里是申请一个递减的优先队列，按照迟到的损失进行排序
    for(int i = 1; i <= k; i++)    //先把前面已经迟到的进行入队，并且排好序
    {
        q.push(a[i]);
    }
    for(int i = k+1; i <= k+n; i++)   //把损失最大的往前排，使得损失降到最低
    {
        if(i <= n)
            q.push(a[i]);
        plane temp = q.top();
        q.pop();
        result += (long long)(i-temp.num)*(long long )temp.x;    //记录总和
        ans[temp.num] = i;
    }
    printf("%lld\n",result);
    for(int i = 1; i <= n; i++)
    {
        if(i == 1)
           printf("%d", ans[i]);
        else
           printf(" %d", ans[i]);
    }
    printf("\n");
    return 0;
}