Physical Examination

 Physical Examination

Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u

Description

WANGPENG is a freshman. He is requested to have a physical examination when entering the university.
Now WANGPENG arrives at the hospital. Er….. There are so many students, and the number is increasing!
There are many examination subjects to do, and there is a queue for every subject. The queues are getting longer as time goes by. Choosing the queue to stand is always a problem. Please help WANGPENG to determine an exam sequence, so that he can finish all the physical examination subjects as early as possible.

 

Input

There are several test cases. Each test case starts with a positive integer n in a line, meaning the number of subjects(queues).
Then n lines follow. The i-th line has a pair of integers (ai, bi) to describe the i-th queue:
1. If WANGPENG follows this queue at time 0, WANGPENG has to wait for ai seconds to finish this subject.
2. As the queue is getting longer, the waiting time will increase bi seconds every second while WANGPENG is not in the queue.
The input ends with n = 0.
For all test cases, 0<n≤100000, 0≤a _i,b _i<2 ³¹.

 

Output

For each test case, output one line with an integer: the earliest time (counted by seconds) that WANGPENG can finish all exam subjects. Since WANGPENG is always confused by years, just print the seconds mod 365×24×60×60.

 

Sample Input

         
         

          
          5
1 2
2 3
3 4
4 5
5 6
0
         
         

 

Sample Output

         
         

          
          1419

         
         

Hint

In the Sample Input, WANGPENG just follow the given order. He spends 1 second in the first queue, 5 seconds in the 2th queue, 27 seconds in the 3th queue, 
169 seconds in the 4th queue, and 1217 seconds in the 5th queue. So the total time is 1419s. WANGPENG has computed all possible orders in his 
120-core-parallel head, and decided that this is the optimal choice.
 

 

题目描述：排队，每次选择最优的队伍使得最后所花时间最短。

                   输入a,b：a表示如果当前马上来排队的话，所需的等待时间；b表示此后每晚来一分钟所带来的等待代价。例如，对第i队来说，现在要去排的话，再过a分钟就到你了。如果先去了别的队伍，过x分钟后再回来这个队伍排的话，需要再等待a+x*b分钟才到你。

                  题目要求找出最优的排队方案（所有的队都排完），输出最短的总时间。

                  算法分析：加入有a1,a2两个队伍，如果先选a1,则排完1队再去2队，总共时间为：a1+a1*b2+a2;

(a1*b1表示花了a1个时间完成1队后，在2队增加的排队时间）。

                  同理，如果先选2对，时间为：a2+a2*b1+a1;

                  比较两种方案，时间差别只在于a1*b1与a2*b1，所以根据贪心算法，只要比较这两个的大小即可得出最优方案。如果a1*b1>a2*b1，则先去排1队。

AC代码：

#include<iostream>
#include<stdio.h>
#include<algorithm>
using namespace std;
const int M = 31536000;
struct Node{
       long long a,b;
       }s[100002];
       
bool cmp(Node s1,Node s2)
{
     return s1.a*s2.b < s2.a*s1.b;
}
int main()
{
    int num;
    while(scanf("%d",&num),num)
    {
   	  for(int i=0;i<num;i++)  scanf("%d%d",&s[i].a,&s[i].b);
      sort(s,s+num,cmp);
      long long ans=0;
      for(int j=0;j<num;j++)
      {
        int t = (s[j].a%M+s[j].b*ans%M)%M;
        ans = (ans+t)%M;
      }
      printf("%lld\n",ans);
      }
    return 0;}