集训第四周（高效算法设计）G题 (贪心）

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<tex2html_verbatim_mark> , the amount of steel required (in tons) and d<tex2html_verbatim_mark> , 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<tex2html_verbatim_mark> tons of steel takes exactly q<tex2html_verbatim_mark> 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 J₁,..., J₆<tex2html_verbatim_mark> . For a given order, J_j<tex2html_verbatim_mark> , q_j<tex2html_verbatim_mark> denotes the amount of steel required and d_j<tex2html_verbatim_mark> 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 J₁<tex2html_verbatim_mark> and J₄<tex2html_verbatim_mark> , accept all other orders and process them as follows.

Note that the production line is never idle.

Input 

The input begins with a single positive integer on a line by itself indicating the number of the cases following, each of them as described below. This line is followed by a blank line, and there is also a blank line between two consecutive inputs.

Data Each test case is described by one input file that contains all the relevant data: The first line contains the number n<tex2html_verbatim_mark> of orders ( n<tex2html_verbatim_mark> can be as large as 800000 for some test cases). It is followed by n<tex2html_verbatim_mark> 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⁶<tex2html_verbatim_mark> ).

Output 

For each test case, the output must follow the description below. The outputs of two consecutive cases will be separated by a blank line.

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

Sample Input 

1

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

Sample Output 

4

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 J_u<tex2html_verbatim_mark> and J_v<tex2html_verbatim_mark> with q_u > q_v<tex2html_verbatim_mark> and d_u < d_v<tex2html_verbatim_mark> , if J_u<tex2html_verbatim_mark> is accepted then J_v<tex2html_verbatim_mark> is also accepted.
• Finally, Hogdson and Moore advise you to ``Keep the Customer Satisfied"

Keep the Customer Satisfied

Gee but it‘s great to be back home 
Home is where I want to be. 
I‘ve been on the road so long my friend, 
And if you came along
I know you couldn‘t disagree.

It‘s the same old story 
Everywhere I go, 
I get slandered, 
Libeled, 
I hear words I never heard 
In the bible 
And I‘m on step ahead of the shoe shine 
Two steps away from the county line 
Just trying to keep my customers satisfied, 
Satisfied.

Deputy sheriff said to me 
Tell me what you come here for, boy. 
You better get your bags and flee. 
You‘re in trouble boy, 
And you‘re heading into more.

©Simon & Garfunkel

题意，钢铁厂会接到一些订单，其中有一些无法完成，需要拒绝，他们希望需要拒绝的订单越少越好，要求输出需要拒绝的订单数

贪心，先排序，限期紧的放在前面，在小于当前订单日期限值之前，你当然是肆无忌惮得接下订单了，如果你在选择某一个订单时发现期限会超出，先不要忙着拒绝它，如果你之前选择的某个订单需求数（需求数越大，所耗时间也就越大）比它还大，那就忍痛拒绝那个大订单，反正要求是接下的订单数越多越好，业绩什么的也就不管啦.........赔本赚吆喝吧

还有，怎么找那个更需要拒绝的订单？遍历一遍数组？数组最长可达80万如果遍历时间复杂度为O(n^2)，三秒绝对跑不完，所以使用优先队列记录q，快得妥妥的

#include"iostream"
#include"algorithm"
#include"queue"
using namespace std;

const int maxn=800000+10;

struct node
{
    int q,d;
}a[maxn];

bool cmp(struct node a1,struct node a2)
{
    return a1.d<a2.d;
}


int n;


void Init()
{
    cin>>n;
    for(int i=0;i<n;i++) cin>>a[i].q>>a[i].d;
}

void Work()
{
    sort(a,a+n,cmp);
    int ans=n,cur=0;
    priority_queue<int>que;
    for(int i=0;i<n;i++)
    {
      cur+=a[i].q;
      que.push(a[i].q);
     if(cur>a[i].d)
     {
         cur-=que.top();
         que.pop();
         ans--;
     }
    }
    cout<<ans<<endl;
}

int main()
{
    int T,t;
    cin>>T;
    t=T;
    while(T--)
    {
        if(t!=T+1) cout<<endl;
        Init();
        Work();
    }
    return 0;
}