POJ 2970 The lazy programmer

The lazy programmer

Time Limit: 5000MS		Memory Limit: 65536K
Total Submissions: 2785		Accepted: 703

Description

A new web-design studio, called SMART (Simply Masters of ART), employs two people. The first one is a web-designer and an executive director at the same time. The second one is a programmer. The director is so a nimble guy that the studio has already got N contracts for web site development. Each contract has a deadline d_i.

It is known that the programmer is lazy. Usually he does not work as fast as he could. Therefore, under normal conditions the programmer needs bi of time to perform the contract number i. Fortunately, the guy is very greedy for money. If the director pays him x_i dollars extra, he needs only (b_i − a_i x_i) of time to do his job. But this extra payment does not influent other contract. It means that each contract should be paid separately to be done faster. The programmer is so greedy that he can do his job almost instantly if the extra payment is (b_i ⁄ a_i) dollars for the contract number i.

The director has a difficult problem to solve. He needs to organize programmer’s job and, may be, assign extra payments for some of the contracts so that all contracts are performed in time. Obviously he wishes to minimize the sum of extra payments. Help the director!

Input

The first line of the input contains the number of contracts N (1 ≤ N ≤ 100 000, integer). Each of the next N lines describes one contract and contains integer numbers a_i, b_i, d_i (1 ≤ a_i, b_i ≤ 10 000; 1 ≤ d_i ≤ 1 000 000 000) separated by spaces.

Output

The output needs to contain a single real number S in the only line of file. S is the minimum sum of money which the director needs to pay extra so that the programmer could perform all contracts in time. The number must have two digits after the decimal point.

Sample Input

2
20 50 100
10 100 50

Sample Output

5.00

Source

Northeastern Europe 2004, Western Subregion

题目链接

 

题意 

有n项任务，每项任务一般需要b时间，要在d前完成，有需要的话，可以用钱加速，有公式c=b-a*x，其中x为金钱，c为完成改任务的时间，因此如果给的钱够多，一项任务可以瞬间完成。现在问若要把每个任务都及时完成，最少需要多少钱？

分析 

贪心来做，按照d从小到大排序，然后遍历任务列表，计算时间，若当前时间超过该任务的d了，就找到前面完成的任务中a最大的那个，加速它来获取需要的时间，因为这样才能花费最少，如何找到a最大那个呢？我们可以使用优先队列

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#include <queue>
#include <vector>
#include<bitset>
#include<map>
using namespace std;
typedef long long LL;
const int maxn = 1e5+;
const int mod = +;
typedef pair<int,int> pii;
#define X first
#define Y second
#define pb push_back
#define mp make_pair
#define ms(a,b) memset(a,b,sizeof(a))
const int inf = 0x3f3f3f3f;
#define lson l,m,2*rt
#define rson m+1,r,2*rt+1
struct node {
    int a,b,d;
    bool operator < (const node &rhs)const{
        return a<rhs.a;
    }
}work[maxn];

int cmp(node a,node b){
    return a.d<b.d;
}

int main(){
//    freopen("in.txt","r",stdin);
    int n;
    while(~scanf("%d",&n)){
        for(int i=;i<n;i++){
            scanf("%d%d%d",&work[i].a,&work[i].b,&work[i].d);
        }
        sort(work,work+n,cmp);
        priority_queue<node> q;
        int sum=;
        double ans=0.0;
        for(int i=;i<n;i++){
            sum += work[i].b;
            q.push(work[i]);

            while(!q.empty()&&sum>work[i].d){
                node now = q.top();
                q.pop();
                int res=sum-work[i].d;
                if(res>=now.b){

                    ans += 1.0*now.b/now.a;
                    sum -= now.b;
                }else{
                    now.b -= res;
                    sum -= res;
                    ans += 1.0*res/now.a;
                    q.push(now);
                }
            }
        }
        printf("%.2f\n",ans);

    }

    return ;
}