UVALive - 6440

题目链接：https://vjudge.net/contest/241341#problem/G

Indonesia, as well as some neighboring Southeast Asian countries and some other East Asian countries, is located in the Pacific Ring of Fire which rather frequently causes volcanic eruptions, large earthquakes, and tsunamis. Handling hospital emergency situations effectively is critical for such countries laden with natural disasters. A leading local hospital recently has asked some computer scientists to help them optimize their emergency handling especially under large volume of cases. During a day, patients may come to the emergency department with different severity (e.g. suffering from broken bone is more severe than suffering from flu) and with different rate of increase of severity (e.g., burn injury if not treated immediately can be very dangerous, compared to broken bone) For a simplified model, suppose a patient arrives at time t0 with initial severity s(t0) and rate of increase of severity per unit of time r. Then the severity at time t becomes s(t) = s(t0) + r·(t−t0) The hospital has only limited facility and workforce to handle the patients so they want to prioritize the handling the best they can. More precisely, at any time t, if the hospital can admit one of the patients to treat, it must choose the patient with the highest severity s(t) at that time t. If there are ties, it must choose the patient with the highest rate of increase of severity r. If there are still ties, any one of the tied patients can be chosen. We assume that once a patient is chosen and given care, the patient will be safe and is no longer in the list of waiting patients. Given the sequence of incoming patients and admission of patients, help the hospital to determine the best patient to admit at each admission event.
Input The first line of input contains an integer T (T ≤ 5) denoting the number of cases. Each case begins with an integer N (1 ≤ N ≤ 100,000) denoting the number of events. For the next N lines, each line describes either an incoming patient or an admission event. • For an incoming patient, the line contains a character ‘P’ and three integers t0, s(t0) and r that describe the patient (0 ≤ t0 ≤ 106; 0 ≤ s(t0) ≤ 108; 0 ≤ r ≤ 100). • For an admission, the line contains a character ‘A’ followed by an integer t, which is the time of the event. You may assume that there is at least one patient waiting in the emergency department when this admission event occurs.
The events are specified in strictly increasing order of time. The number of ‘P’ and ‘A’ events will be roughly balanced.
Output
For each case, output ‘Case #X:’ in a line, where X is the case number starts from 1. For each of the admission event, output two integers separated by a single space: the current severity of the chosen patient at the admission time and that patient’s rate of increase of severity.
Sample Input
2 9 P 10 10 1 P 30 20 1 A 35 P 40 20 2 P 60 50 3 A 75 P 80 80 3 A 100 A 110 6 P 1 10 2 A 5 P 10 10 1 P 11 1 10 A 15 A 20
Sample Output
Case #1: 35 1 95 3 140 3 160 2 Case #2: 18 2 41 10 20 1

题目大意：输入t，t组样例，输入n，n个操作，接下来如果输入的是'P',那么代表此刻有人进来，如果输入的是'A,代表可以有一个病人去看病，求每次看病最严重的增加率最高的病人

思路：这里要介绍一下优先队列这个概念：优先队列可以自动按从大到小排序或者从小到大排序，取元素用p.top(),删除元素用p.pop()····，然后具体从小到大还是从大到小学习这篇博客：

https://blog.csdn.net/c20182030/article/details/70757660

具体思路看代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<stdio.h>
#include<string.h>
#include<cmath>
#include<math.h>
#include<algorithm>
#include<set>
#include<queue>
#include<map>
typedef long long ll;
using namespace std;
const ll mod=1e9+7;
const int maxn=2e4+10;
const int maxk=100+10;
const int maxx=1e4+10;
const ll maxe=1000+10;
#define INF 0x3f3f3f3f3f3f
priority_queue<int>p[110];//优先队列
void init()
{
    for(int i=0;i<=100;i++)
    {
        while(!p[i].empty())//使得队列为空
       //while(p[i].size())
            p[i].pop();
    }
}
int main()
{
    int t;
    int sum=1;
    cin>>t;
    while(t--)
    {
        init();
        printf("Case #%d:\n",sum++);
        ll n,st0,t0,t1,r,id,va;
        char a[5];
        cin>>n;
        for(int i=1;i<=n;i++)
        {
            cin>>a;
            if(a[0]=='P')
            {
                cin>>t0>>st0>>r;
                p[r].push(st0-r*t0);//注意这里为什么要这样处理，因为st=st0+(t-t0)*r····所以呢，可以得到stt=t*r; 这样的
                //话st就只和r有关了，不管初始大小多大，当r一样时，两者相对来说差距是不变的
            }
            else
            {
                cin>>t1;
                id=-1;
                va=-INF;
                for(int j=100;j>=0;j--)//为什么从100开始呢？因为如果va相等，优先取r更大的，题目要求
                {
                    if(p[j].empty()) continue;
                   // if(p[j].size()==0) continue;
                    ll vaa=p[j].top();//这里每次都会取在r相同情况下最大的vaa，这也是优先队列的好处
                    vaa=vaa+j*t1;
                    if(vaa>va)
                    {
                        va=vaa;
                        id=j;
                    }
                }
                p[id].pop();
                cout<<va<<" "<<id<<endl;
            }
        }
    }
    return 0;
}