[堆+贪心]牛客练习赛40-B

传送门：牛客练习赛40

题面：

小A手头有 n 份任务，他可以以任意顺序完成这些任务，只有完成当前的任务后，他才能做下一个任务

第 i 个任务需要花费  x_i 的时间，同时完成第 i 个任务的时间不能晚于 y_i ，时间掌控者向小A提出了一个条件：如果完成第 i 个任务的时间本应是 t ，但小A支付 m 个金币的话，他可以帮助小A在 t-m*z_i  时刻完成第 i 个任务， z_i 是时间参数，会在输入中给出

小A想按时完成所有任务，请你帮他制定一个花费金币最少的方案

注意：不能使得某个任务的花费时间小于 0 ,花费的金币可以不是整数

思路：

首先不难想到一个贪心策略：

1.优先完成截止时间靠前的任务。（以y[i]为关键字，从小到大排序，从左到右处理）

2.如果超出截止时间（t > y[i]），花费尽量少的金币缩短时间（ ans += (t-y[i]) / z[i]）

这样的贪心策略是存在问题的。如果靠后的任务不够时间完成，同时这个任务的 z 较小，而前面存在 z 特别大的任务，我们应该支付（更少的）金币去缩短前面的时间。

那么我们对上面的贪心策略做出修改：

1.时间充足的情况下（t+x[i] <= y[i]), 优先完成截止时间靠前的任务.（t += x[i])

2.如果超出截止时间（t > y[i]), 找出前面还能缩短时间 且 z[i] 最大的。

这样一来，正确性上没有问题了，但每次暴力查找能够缩短时间且z[i]最大的，复杂度撑不住。

事实上，我们应该想到，最适合维护这个东西的就是堆(priority_queue)了

代码仅供参考：

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
typedef pair<ll,ll> pii;
#define ____ ios::sync_with_stdio(false);cin.tie(0);
#define fir first
#define sec second
#define mkp make_pair
#define pb push_back
#define lson l,mid,p<<1
#define rson mid+1,r,p<<1|1
const ll INF = (1LL<<60) - 1;
const double eps = 1e-9;
//head
const int maxn = 2e5 + 5;
struct Node{
    int k,t,ddl;
    bool operator < (const Node & rhs) const {
        return ddl < rhs.ddl;
    }
} a[maxn];
struct node{
    ll k,t;
    node(double k,double t):k(k),t(t){};
    node(){};
    bool operator < (const node & rhs) const {
        return k < rhs.k;
    }
};
int n;
int main(){
    //freopen("data.in","r",stdin);
    ____
    cin >> n;
    for(int i = 1; i <= n; i++){
        cin >> a[i].k >> a[i].t >> a[i].ddl;
    }
    sort(a+1, a+n+1);
    priority_queue<node> q;
    ll t = 0;
    double ans = 0;
    for(int i = 1; i <= n; i++){
        t += a[i].t;
        ll t_in_i = a[i].t;
        if(t > a[i].ddl){
            while((!q.empty()) && a[i].k < q.top().k){
                node u = q.top();
                q.pop();
                if(u.t > t-a[i].ddl){
                    u.t -= t-a[i].ddl;
                    ans += double(t-a[i].ddl)/u.k;
                    t = a[i].ddl;
                    if(u.t){
                        q.push(u);
                    }
                    break;
                }
                else{
                    t -= u.t;
                    ans += double(u.t)/u.k;
                }
            }
            if(t > a[i].ddl){
                ans += double(t - a[i].ddl)/a[i].k;
                t_in_i -= t - a[i].ddl;
                t = a[i].ddl;
            }
        }
        if(t_in_i){
            q.push(node(a[i].k,t_in_i));
        }
    }
    cout << fixed << setprecision(1) << ans << endl;
    return 0;
}