poj2786 Keep the Customer Satisfied

Keep the Customer Satisfied

Time Limit: 10000MS		Memory Limit: 65536K
Total Submissions: 1497		Accepted: 574

Description

Simon and Garfunkel Corporation (SG Corp.) is a large steel-making company with thousand of customers. Keeping the customer satisfied is one of the major objective of Paul and Art, the managers.

Customers issue orders that are characterized by two integer values q , the amount of steel required (in tons) and d , the due date (a calender date converted in seconds). The due date has to be met if SG Corp. accepts the order. Stated another way, when an order is accepted, the corresponding amount of steel has to be produced before its due date. Of course, the factory can process no more than one order at a time.

Although the manufacturing process is rather complex, it can be seen as a single production line with a constant throughput. In the following, we assume that producing q tons of steel takes exactly q seconds (i.e., throughput is 1). The factory runs on a monthly production plan. Before the beginning of the month, all customers' orders are collected and Paul and Art determine which of them are going to be accepted and which ones are to be rejected in the next production period. A production schedule is then designed. To keep customers satisfied, Paul and Art want to minimize the total number of orders that are rejected. In the following, we assume that the beginning of the next production plan (i.e., the first day of the next month) corresponds to date 0.

Hogdson and Moore have been appointed as Chief Scientific Officers and you are requested to help them to compute an optimal solution and to build a schedule of all accepted orders (starting time and completion time).
Small Example
Consider the following data set made of 6 orders J1,..., J6 . For a given order, Jj , qj denotes the amount of steel required and dj is the associated due date.

You can check by hand that all orders cannot be accepted and it's very unlikely you could find a solution with less than two rejected orders. Here is an optimal solution: Reject J1 and J4 , accept all other orders and process them as follows.

Note that the production line is never idle.

Input

The first line contains the number n of orders (n can be as large as 800000 for some test cases). It is followed by n lines. Each of which describes an order made of two integer values: the amount of steel (in tons) required for the order (lower than 1000) and its due date (in seconds; lower than 2 x 10 ⁶ ).

Output

You are required to compute an optimal solution and your program has to write the number of orders that are accepted.

Sample Input

6
7 15
8 20
6 8
4 9
3 21
5 22

Sample Output

4

Hint

Some Hints from Hogdson and Moore
Hogdson and Moore claim that it is optimal to sequence accepted orders in non-decreasing order of due dates.
They also claim that there is an optimal solution such that for any two orders Ju and Jv with qu > qv and du < dv , if Ju is accepted then Jv is also accepted.
Finally, Hogdson and Moore advise you to ``Keep the Customer Satisfied"

Keep the Customer Satisfied

/*接着对于当前新的工作，若按当前选择的工作的情况无法在截止时
间之前完成这个工作，分2种情况讨论：（1）当前工作需要的时间比
选择的队列中工作时间最长的还要长，就放弃这个工作，使完成相同
数目工作的耗时尽量小；（2）工作时间比队列中时间最长的要短，就
删去队列中时间最长的任务并且将当前的工作加入队列。--“最优子结
构”  这样O(n)扫一次，加上使用优先队列，时间复杂度就是O(n log n)。*/
#include <iostream>
#include <stdio.h>
#include <math.h>
#include <algorithm>
#include <queue>

using namespace std;
struct node{
    int q, d;
}a[800005];

bool comp(node a, node b){
    return a.d < b.d;
}

int main()
{
    int n;
    cin >> n;
    for(int i = 0; i < n; i++){
        scanf("%d%d", &a[i].q, &a[i].d);
    }
    sort(a, a+n, comp);
    priority_queue<int> Q;
    int ans = 0;
    for(int i = 0; i < n; i++){
        ans += a[i].q;
        Q.push(a[i].q);
        while(ans > a[i].d){
            ans -= Q.top();
            Q.pop();
        }
    }
    printf("%d\n", Q.size());
    return 0;
}