HDU-4442-Physical Examination （2012年金华赛区现场赛A题）

Physical Examination

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 5915    Accepted Submission(s): 1656

Problem 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. 
    
    
    
    
     
   
   
   
   

 

Source

2012 Asia JinHua Regional Contest

 

由简单至复杂，先讨论2个的情况：

a1 b1

a2 b2

如果现有的顺序是最佳顺序，那么一定有关系：

a1 + a1*b2 + a2 <= a2 + a2*b1 + a1

等价于     a1*b2 < a2*b1

那么之后的都按照a1*b2 < a2*b1 来排序！

AC代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int mo=365*24*60*60;
const int maxn=100010;

struct fun
{
	__int64 a,b;
}node[maxn];

bool cmp(fun a, fun b)
{
	return a.a*b.b<b.a*a.b;
}

int main()
{
	int n, i, j;
	while(scanf("%d", &n), n)
	{
		for(i = 0; i<n; i++)
		{
			scanf("%I64d %I64d", &node[i].a, &node[i].b);
		}
		sort(node, node+n, cmp);
		__int64 ans = 0, tem = 0;
		for(i = 0; i<n; i++)
		{
			ans+=(node[i].a+tem*node[i].b)%mo;
			ans%=mo;
			tem = ans;
		}
		printf("%I64d\n", ans);
	}
	return 0;
}  

其实我还看了看别人的代码（感觉我的代码逻辑不对劲，但是过了）：

a1 b1

a2 b2

如果现有的顺序是最佳顺序，那么一定有关系：

a1 + a1*b2 + a2 <= a2 + a2*b1 + a1

还可以等价于 a1/b1 < a2/b2

这样使得a1和b1在一块了，a2和b2在一块了，对于往后退可以更方便。

比如三组：

a1  b1

a2  b2

a3  b3

可以得到   a1/b1  <  a2/b2   <   a3/b3

以此类推，也可以按照这样排序！

代码（别人的代码，没提交过。。）：

#include<iostream>
#include<cstdlib>
#include<vector>
#include<map>
#include<cstring>
#include<set>
#include<string>
#include<algorithm>
#include<sstream>
#include<ctype.h>
#include<fstream>
#include<string.h>
#include<stdio.h>
#include<math.h>
#include<stack>
#include<queue>
#include<ctime>
//#include<conio.h>
using namespace std;

const int INF_MAX=0x7FFFFFFF;
const int INF_MIN=-(1<<30);

const double eps=1e-10;
const double pi=acos(-1.0);

#define pb push_back   //a.pb( )
#define chmin(a,b) ((a)<(b)?(a):(b))
#define chmax(a,b) ((a)>(b)?(a):(b))


template<class T> inline T gcd(T a,T b)//NOTES:gcd(
  {if(a<0)return gcd(-a,b);if(b<0)return gcd(a,-b);return (b==0)?a:gcd(b,a%b);}
template<class T> inline T lcm(T a,T b)//NOTES:lcm(
  {if(a<0)return lcm(-a,b);if(b<0)return lcm(a,-b);return a*(b/gcd(a,b));}


typedef pair<int, int> PII;
typedef vector<PII> VPII;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef long long LL;
int dir_4[4][2]={{0,1},{-1,0},{0,-1},{1,0}};
int dir_8[8][2]={{0,1},{-1,1},{-1,0},{-1,-1},{0,-1},{1,-1},{1,0},{1,1}};
//下，左下，左，左上，上，右上，右，右下。

//******* WATER ****************************************************************


struct node {
    LL a, b;
    double d;
    bool operator < (const node& k) const{
        return a < k.a; //升序
    }
};

vector<node> vn;

LL calc() {
    LL mod = 365 * 24 * 60 * 60;
    LL ret = 0;
    LL sum = 0;
    for(int i = 0; i < vn.size(); i++) {
        ret = sum * vn[i].b + vn[i].a;
        sum += ret;
        sum %= mod;
    }
    return sum;
}

int main() {
    int n;
    node tmp;
    while(scanf("%d", &n) && n) {
        vn.clear();
        for(int i = 0; i < n; i++) { scanf("%I64d%I64d", &tmp.a, &tmp.b); tmp.d = (double)tmp.a / (tmp.b - 1);  vn.push_back(tmp);}
        //sort(vn.begin(), vn.end());
        printf("%I64d\n", calc());
    }
    return 0;
}