ybt1870 国王游戏（NOIP2012提高组第2题）（高/低）

ybt1870  国王游戏（NOIP2012提高组第2题）

时空限制    1000ms/128MB

题目描述

        恰逢 H 国国庆，国王邀请 n 位大臣来玩一个有奖游戏。首先，他让每个大臣在左、右手上面分别写下一个整数，国王自己也在左、右手上各写一个整数。然后，让这 n 位大臣排成一排，国王站在队伍的最前面。排好队后，所有的大臣都会获得国王奖赏的若干金币，每位大臣获得的金币数分别是：排在该大臣前面的所有人的左手上的数的乘积除以他自己右手上的数，然后向下取整得到的结果。

        国王不希望某一个大臣获得特别多的奖赏，所以他想请你帮他重新安排一下队伍的顺序，使得获得奖赏最多的大臣，所获奖赏尽可能的少。注意，国王的位置始终在队伍的最前面。

输入

        第一行包含一个整数 n，表示大臣的人数。

        第二行包含两个整数 a 和 b，之间用一个空格隔开，分别表示国王左手和右手上的整数。

        接下来 n 行，每行包含两个整数 a 和  b，之间用一个空格隔开，分别表示每个大臣左手和右手上的整数。

输出

        一个整数，表示重新排列后的队伍中获奖赏最多的大臣所获得的金币数。

输入样例

3
1 1
2 3
7 4
4 6

输出样例

2

说明/提示

【输入输出样例说明】

按 1 、2 、3 这样排列队伍，获得奖赏最多的大臣所获得金币数为 2；

按 1 、3 、2 这样排列队伍，获得奖赏最多的大臣所获得金币数为 2；

按 2 、1 、3 这样排列队伍，获得奖赏最多的大臣所获得金币数为 2；

按 2 、3 、1 这样排列队伍，获得奖赏最多的大臣所获得金币数为 9；

按 3 、1 、2 这样排列队伍，获得奖赏最多的大臣所获得金币数为 2；

按 3 、2 、1 这样排列队伍，获得奖赏最多的大臣所获得金币数为 9 。

因此，奖赏最多的大臣最少获得 2 个金币，答案输出 2 。

【数据范围】

对于 20%的数据，有 1≤n≤10,0<a,b<8；

对于 40%的数据，有 1≤n≤20,0<a,b<8；

对于 60%的数据，有 1≤n≤100；

对于 60%的数据，保证答案不超过 10^9；

对于 100%的数据，有 1≤n≤1,000,0<a,b<10000。

NOIP 2012 提高组 第一天 第二题

代码

法一：数组模拟

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 1005, M = 4010;
struct person{
	int a,b;
	bool operator < (const person &T)const{ return a*b<T.a*T.b; }
}p[N];
int n,c[M],d[M],ans[M];	//c累乘数组 d商数组 ans答案数组

void mul(int a[],int x){	//高*低
	for (int i=1; i<=a[0]; ++i) a[i]*=x;
	for (int i=1; i<=a[0]; ++i)
		a[i+1]+=a[i]/10,a[i]%=10;
	while (a[a[0]+1]){
		a[0]++;
		a[a[0]+1] += a[a[0]]/10;
		a[a[0]] %= 10;
	}
}

void div(int a[],int x,int b[]){	//高/低
	memset(b,0,sizeof(int)*M);
	b[0] = a[0];
	for (int i=b[0],r=0; i>=1; --i){
		r = 10*r+a[i];
		b[i] = r/x;
		r %= x;
	}
	while (b[b[0]]==0 && b[0]>1) --b[0];
}

bool isbig(int a[],int b[]){	//比较大小 返回a>b
	if (a[0]!=b[0]) return a[0]>b[0];
	for (int i=a[0]; i>=1; --i)
		if (a[i]!=b[i]) return a[i]>b[i];
	return false;	//等时，返回false
}

void output(int a[]){
	for (int i=a[0]; i>=1; --i) cout<<a[i];
	cout<<'\n';
}

int main(){
	cin>>n;
	for (int i=0; i<=n; ++i) cin>>p[i].a>>p[i].b;
	sort(p+1,p+n+1); 		//国王不参与排序
	memset(c,0,sizeof(c)); c[0]=c[1]=1;	//累乘数组，初始化为1
	memset(ans,0,sizeof(ans)); ans[0]=1;//答案数组，初始化为0
	for (int i=1; i<=n; ++i){
		mul(c,p[i-1].a);	//前面的所有人的左手上的数的乘积 乘积存于c
		div(c,p[i].b,d);	//除以他自己右手上的数 商存于d
		if (isbig(d,ans)) copy(d,d+M,ans);	//打擂
	}
	output(ans);
	return 0;
}

法二：重载运算符

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = 1005, M = 4010;
struct person{
	int a,b;
	bool operator < (const person &T)const{ return a*b<T.a*T.b; }
}p[N];
struct bign{
	int len,d[M];
	bign(){ memset(d,0,sizeof(d)); len=1; }	//构造函数，默认初始化
	bign(int x){							//构造函数，int初始化
		memset(d,0,sizeof(d));
		len = 0;
		do {
			d[++len] = x%10;
			x /= 10;
		} while (x);
	}
	void clear0(){	//成员函数  清掉高位0，保证至少1位
		while (d[len]==0 && len>1) --len;
	}
	bign operator * (const int &b){	//重载* 高*低
		bign c;
		c.len = len;
		for (int i=1; i<=len; ++i) c.d[i]=d[i]*b;
		for (int i=1; i<=len; ++i)
			c.d[i+1]+=c.d[i]/10,c.d[i]%=10;
		while (c.d[c.len+1]){
			c.len++;
			c.d[c.len+1] += c.d[c.len]/10;
			c.d[c.len] %= 10;
		}
		c.clear0();
		return c;
	}
	bign operator *= (const int &b){//重载*=
		*this = *this*b;
		return *this;
	}
	bign operator / (const int &b){	//重载/ 高/低
		bign c;
		c.len = len;
		for (int i=len,r=0; i>=1; --i){
			r = 10*r+d[i];
			c.d[i] = r/b;
			r %= b;
		}
		c.clear0();
		return c;
	}
	bool operator < (const bign &x){//重载<
		if (len!=x.len) return len<x.len;
		for (int i=len; i>=1; --i)
			if (d[i]!=x.d[i]) return d[i]<x.d[i];
		return false;
	}
	friend ostream& operator << (ostream& output,const bign &x){//重载输出流
		for (int i=x.len; i>=1; --i) cout<<x.d[i];
		return output;
	}
};
int main(){
	int n;
	cin>>n;
	for (int i=0; i<=n; ++i) cin>>p[i].a>>p[i].b;
	sort(p+1,p+n+1);		//国王不参与排序
	bign x=1,y,ans=0;		//需重载 int赋值
	for (int i=1; i<=n; ++i){
		x *= p[i-1].a;		//需重载高*低、*=
		y = x/p[i].b;		//需重载高/低
		if (ans<y) ans=y;	//需重载<
	}
	cout<<ans<<'\n'; 		//需重载输出流
	return 0;
}