poj2970 优先队列

题目链接：http://poj.org/problem?id=2970

The lazy programmer

Time Limit: 5000MS		Memory Limit: 65536K
Total Submissions: 1261		Accepted: 312

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

题意：就是有n件工作，每件工作有一个deadline d，一个预计完成需要的时间 b，还有一个a （如果你给这个人x元，那么他完成这件工作的时间就变为b - a * x)。题目所求是问你最少需要多少时间，便可以保证所有工作都在其deadline之前完成。

简单题解：

肯定先按d从小到大排序，小的先完成，记录下到这个任务完成的总时间，如果大于这个任务的d，那么就得对前面的任务付钱，易知优先对a大的付钱，直到b减为0为止，所以用优先队列维护下。。

代码：

/**
 * @author neko01
 */
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
#include <cmath>
#include <set>
#include <map>
using namespace std;
typedef long long LL;
#define min3(a,b,c) min(a,min(b,c))
#define max3(a,b,c) max(a,max(b,c))
#define pb push_back
#define mp(a,b) make_pair(a,b)
#define clr(a) memset(a,0,sizeof a)
#define clr1(a) memset(a,-1,sizeof a)
#define dbg(a) printf("%d\n",a)
typedef pair<int,int> pp;
const double eps=1e-9;
const double pi=acos(-1.0);
const int N=100005;
struct node{
    int a,b,d;
    bool operator < (const node &tmp) const{
        return a<tmp.a;              //以a值为优先值优先队列
    }
}p[N];
bool cmp(const node &u,const node &v)
{
    return u.d<v.d;
}
priority_queue<node>q;
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        for(int i=0;i<n;i++)
            scanf("%d%d%d",&p[i].a,&p[i].b,&p[i].d);
        int time=0;
        double ans=0;
        while(!q.empty()) q.pop();
        sort(p,p+n,cmp);
        for(int i=0;i<n;i++)
        {
            time+=p[i].b;
            q.push(p[i]);
            while(!q.empty()&&time>p[i].d)
            {
                node cur=q.top();
                q.pop();
                if(time-cur.b>p[i].d)
                {
                    ans+=cur.b*1.0/cur.a;
                    time-=cur.b;
                }
                else
                {
                    ans+=(time-p[i].d)*1.0/cur.a;
                    cur.b-=(time-p[i].d);
                    time=p[i].d;
                    q.push(cur);
                }
            }
        }
        printf("%.2lf\n",ans);
    }
    return 0;
}