Luogu_1080_国王游戏

题目描述

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

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

输入输出格式

输入格式

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

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

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

输出格式

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

样例

INPUT

3

1 1

2 3

7 4

4 6

OUTPUT

HINT

【输入输出样例说明】

按$ 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$；

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

NOIP 2012 提高组第一天第二题

SOLUTION

贪心+排序

这题其实和奶牛吃花的那题非常相似。

我们在队伍中随意取相邻两个人进行分析。

由题意可知，这两个人排列的先后顺序对他们前面的人与他们后面的人的得到奖励的计算不会产生影响。

于是我们假定一人编号为$i$，另一人为$i+1$，因为前面的人左手的积和$A,B$的排列顺序无关，我们把其设为$M$.

于是：

在保持原顺序与否的情况下得到：

$i$得到的最大奖励为：$Max(\frac {M}{b_i},\frac {M\cdot a_{i+1}}{b_i})$；

$i+1$得到的最大奖励为：$Max(\frac {M}{b_{i+1}},\frac {M\cdot a_i}{b_{i+1}})$；

把这四个式子同乘 $\frac {b_i \cdot b_{i+1}}{M}$，得到

$i$的最大奖励为:$Max(b_{i+1},a_{i+1}\cdot b_{i+1})$，即$a_{i+1}\cdot b_{i+1}$

$i+1$的最大奖励为:$Max(b_i,a_{i}\cdot b_i)$，即$a_i\cdot b_i$

若$a_{i+1}\cdot b_{i+1}> a_i\cdot b_i$则说明在交换的情况下得到的最大值会比交换前的大，不能进行交换，所以当$i,i+1$满足$a_i\cdot b_i<a_{i+1}\cdot b_{i+1}$时，不必交换顺序。

从lyd书上抄的一段然后我们能够根据冒泡排序的知识，有：任何一个序列都能通过邻项交换的方式变为有序序列。故当逆序对数为0，即按上面规律排序时就是最优策略。

接着记得写好高精就行qwq

这题我一个不熟悉重载的人用重载写高精，调的时间比我推式子的时间还长qwq。

#include <iostream>

#include <cstdio>

#include <cstring>

#include <cstdlib>

#include <algorithm>

using namespace std;

typedef long long LL;

inline int read(){

	int x=0,f=1;char ch=getchar();

	while (ch<'0'||ch>'9') {if (ch=='-') f=-1;ch=getchar();}

	while (ch>='0'&&ch<='9') {x=x*10+ch-48;ch=getchar();}

	return x*f;}

const int NUM=1000,N=101000;

const int M=10000;

struct Bignumber{

	int len,b[NUM];

	Bignumber(){len=0;memset(b,0,sizeof(b));}

	inline void clear(){len=0;memset(b,0,sizeof(b));}

	Bignumber(int x){memset(b,0,sizeof(b));len=0;if (x==0) {len=1;return;}

		while (x) {b[++len]=x%M;x/=M;}}

	inline void print(){

		printf("%d",b[len]);

		for (int i=len-1;i>=1;--i) printf("%04d",b[i]);puts("");}

	inline Bignumber operator *(const int &a)const{

		Bignumber c;c.clear();c.len=len+5;

		for (int i=1;i<=len;++i){

			c.b[i]+=b[i]*a;c.b[i+1]=c.b[i]/M;c.b[i]%=M;}

		while (!c.b[c.len]&&c.len>1) c.len--;

		return c;

	}

	inline Bignumber operator /(const int &a)const{

		Bignumber c;c.clear();c.len=len;int rst=0;

		for (int i=len;i>=1;--i){

			rst=rst*M+b[i];c.b[i]=rst/a;rst%=a;}

		while (!c.b[c.len]&&c.len>1) --c.len;

		return c;}

};

inline Bignumber Max(Bignumber a,Bignumber b){

    if (a.len>b.len) return a;

    if (b.len>a.len) return b;

    for (int i=a.len;i>=1;--i){

        if (a.b[i]==b.b[i]) continue;

        if (a.b[i]>b.b[i]) return a;else return b;}

    return a;}

struct MNST{int l,r;}mst[N];

bool cmp(MNST a,MNST b){return ((a.l*a.r)<(b.l*b.r));}

int n;

int main(){

	int i,j;

	n=read();

	Bignumber mlt;mlt.clear();mlt.len=1;

	int l0=read(),r0=read();

	mlt.b[1]=l0;

	for (i=1;i<=n;++i) {mst[i].l=read();mst[i].r=read();}

	sort(mst+1,mst+1+n,cmp);

	Bignumber ans;ans.clear();ans.len=1;

	for (i=1;i<=n;++i){

		if (mst[i].l==0) break;

		Bignumber rec=mlt/mst[i].r;mlt=mlt*mst[i].l;

		ans=Max(ans,rec);

	}

	ans.print();

	return 0;

}