洛谷P1080 国王游戏

淩亂°似流年 2022-05-31 12:13 231阅读 0赞

## 题目描述 ##

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

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

## 输入输出格式 ##

输入格式：

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

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

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

输出格式：

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

## 输入输出样例 ##

输入样例\#1： 复制

3 
    1 1 
    2 3 
    7 4 
    4 6

输出样例\#1： 复制

## 说明 ##

【输入输出样例说明】

按 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 提高组 第一天 第二题

参考题解：[https://www.luogu.org/blog/cpp/ti-xie-p1080-guo-wang-you-hu-post][https_www.luogu.org_blog_cpp_ti-xie-p1080-guo-wang-you-hu-post]

[https://www.luogu.org/blog/league/solution-p1080][https_www.luogu.org_blog_league_solution-p1080]

贪心+高精度

我们对于国王身后的两个点来分析

队列可能是这样的：

<table style="border-spacing:0px;max-width:100%;color:rgb(51,51,51);font-family:'Segoe UI', 'Lucida Grande', Helvetica, Arial, 'Microsoft YaHei', FreeSans, Arimo, 'Droid Sans', 'wenquanyi micro hei', 'Hiragino Sans GB', 'Hiragino Sans GB W3', FontAwesome, sans-serif;font-size:15px;line-height:24px;"> 
 <thead> 
 <tr> 
 <th style="padding:0px;">*</th> 
 <th style="padding:0px;text-align:right;">Left</th> 
 <th style="padding:0px;text-align:center;">Right</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td style="padding:6px 13px;">king:</td> 
 <td style="padding:6px 13px;text-align:right;">a_0a0</td> 
 <td style="padding:6px 13px;text-align:center;">b_0b0</td> 
 </tr> 
 <tr> 
 <td style="padding:6px 13px;">p1</td> 
 <td style="padding:6px 13px;text-align:right;">a_1a1</td> 
 <td style="padding:6px 13px;text-align:center;">b_1b1</td> 
 </tr> 
 <tr> 
 <td style="padding:6px 13px;">p2</td> 
 <td style="padding:6px 13px;text-align:right;">a_2a2</td> 
 <td style="padding:6px 13px;text-align:center;">b_2b2</td> 
 </tr> 
 </tbody> 
</table>

那么我们计算可得ans\_1*a**n**s*1 =max(\\frac\{a\_0\}\{b\_1\},\\frac\{a\_0\*a\_1\}\{b\_2\})*m**a**x*(*b*1*a*0,*b*2*a*0∗*a*1)

队列也有可能是这样的

<table style="border-spacing:0px;max-width:100%;color:rgb(51,51,51);font-family:'Segoe UI', 'Lucida Grande', Helvetica, Arial, 'Microsoft YaHei', FreeSans, Arimo, 'Droid Sans', 'wenquanyi micro hei', 'Hiragino Sans GB', 'Hiragino Sans GB W3', FontAwesome, sans-serif;font-size:15px;line-height:24px;"> 
 <thead> 
 <tr> 
 <th style="padding:0px;">*</th> 
 <th style="padding:0px;text-align:right;">Left</th> 
 <th style="padding:0px;text-align:center;">Right</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td style="padding:6px 13px;">king:</td> 
 <td style="padding:6px 13px;text-align:right;">a_0a0</td> 
 <td style="padding:6px 13px;text-align:center;">b_0b0</td> 
 </tr> 
 <tr> 
 <td style="padding:6px 13px;">p2</td> 
 <td style="padding:6px 13px;text-align:right;">a_2a2</td> 
 <td style="padding:6px 13px;text-align:center;">b_2b2</td> 
 </tr> 
 <tr> 
 <td style="padding:6px 13px;">p1</td> 
 <td style="padding:6px 13px;text-align:right;">a_1a1</td> 
 <td style="padding:6px 13px;text-align:center;">b_1b1</td> 
 </tr> 
 </tbody> 
</table>

那么我们计算可得ans\_2*a**n**s*2 =max(\\frac\{a\_0\}\{b\_2\},\\frac\{a\_0\*a\_2\}\{b\_1\})*m**a**x*(*b*2*a*0,*b*1*a*0∗*a*2)

我们来对比一下两个答案：

ans\_1*a**n**s*1 =max(\\frac\{a\_0\}\{b\_1\},\\frac\{a\_0\*a\_1\}\{b\_2\})*m**a**x*(*b*1*a*0,*b*2*a*0∗*a*1)

ans\_2*a**n**s*2 =max(\\frac\{a\_0\}\{b\_2\},\\frac\{a\_0\*a\_2\}\{b\_1\})*m**a**x*(*b*2*a*0,*b*1*a*0∗*a*2)

可以替换得：

ans\_1*a**n**s*1 =max(k\_1,k\_2)*m**a**x*(*k*1,*k*2)

ans\_2*a**n**s*2 =max(k\_3,k\_4)*m**a**x*(*k*3,*k*4)

显然我们可以得到:

\\frac\{a\_0\*a\_1\}\{b\_2\}*b*2*a*0∗*a*1 >\\frac\{a\_0\}\{b\_2\}*b*2*a*0

\\frac\{a\_0\*a\_2\}\{b\_1\}*b*1*a*0∗*a*2 >\\frac\{a\_0\}\{b\_1\}*b*1*a*0

即： k\_2*k*2 >k\_3*k*3

k\_4*k*4 >k\_1*k*1

如果ans\_1*a**n**s*1 <ans\_2*a**n**s*2

那么易得：

k\_4>k\_2*k*4>*k*2

即： \\frac\{a\_0\*a\_2\}\{b\_1\}*b*1*a*0∗*a*2 >\\frac\{a\_0\*a\_1\}\{b\_2\}*b*2*a*0∗*a*1

变形可得：

a\_1\*b\_1<a\_2\*b\_2*a*1∗*b*1<*a*2∗*b*2

当a\_1\*b\_1<a\_2\*b\_2*a*1∗*b*1<*a*2∗*b*2 时，我们也能够得到ans\_1*a**n**s*1 <ans\_2*a**n**s*2 的结论

所以，为了ans*a**n**s* 取到最小值，我们需要将a\_i\*b\_i*a**i*∗*b**i* 较小的放在前面

那么我们以a\_i\*b\_i*a**i*∗*b**i* 为关键字排序即可

同时，统计答案时一定不要忘了写高精度！

#include<stdio.h>
 #include<algorithm>
 #include<iostream>
 #include<string.h>
 using namespace std;
 #define maxn 4500
 struct node
 {
 	int l, r;
 }a[1005];
 
 
 /*
 存储规程则:1.以下数组下标为0的元素代表这个数的长度
 		 2.以ans为例,ans[1]到ans[ans[0]]逆序存储数字,即ans[ans[0]]是最高位,ans[1]是最低位
 */
 long long chen[maxn] = { 1, 1 };//用来保存累乘的结果,先初始化为1
 long long tmp[maxn];//用来保存别每次除法的结果
 long long ans[maxn];//最终答案
 
 //按照乘积小的排前面排序
 int cmp(node a, node b)
 {
 	return a.l*a.r < b.l*b.r;
 }
 
 //高精度乘法,如果不明白列竖式
 void highMulity(int k)
 {
 	int t = 0;
 	for (int i = 1; i <= chen[0]; i++)
 	{
 		chen[i] = chen[i] * k + t;
 		t = chen[i] / 10;
 		chen[i] %= 10;
 		if (t > 0 && i >= chen[0])
 			chen[0]++;
 	}
 }
 
 //高精度除法，如果不明白列竖式
 void highDiv(int k)
 {
 	int t = 0; int ok = 1;
 	memset(tmp, 0, sizeof(tmp));
 	for (int i = chen[0]; i > 0; i--)
 	{
 		tmp[i] = (chen[i] + t * 10) / k;
 		t = (chen[i] + t * 10) % k;
 		if (tmp[i] && ok)
 			tmp[0] = i, ok = 0;
 	}
 }
 
 //每次除法完之后和ans数组比较
 bool compare(long long a[], long long b[])
 {
 	if (a[0] < b[0]) 
 		return true; 
 	if (a[0]>b[0])
 		return false;
 	for (int i = a[0]; i > 0;i--)//注意从或往前比较
 	{
 		if (a[i] < b[i])
 			return true;
 		if (a[i]>b[i])
 			return false;
 	}
 	return false;
 }
 
 void print(long long ans[])//打印
 {
 	int i;
 	for (i = ans[0]; i>0 && !ans[i]; i--);
 	for (; i > 0; i--)
 		cout << ans[i];
 }
 
 int main()
 {
 	int n;
 	cin >> n;
 	for (int i = 0; i <= n; i++)
 		cin >> a[i].l >> a[i].r;
 	sort(a + 1, a + 1 + n, cmp);
 
 	for (int i = 0; i < n; i++)
 	{
 		highMulity(a[i].l);
 		highDiv(a[i + 1].r);
 		if (compare(ans, tmp))
 			memcpy(ans, tmp, sizeof(tmp));
 	}
 	print(ans);
 	return 0;
 }

[https_www.luogu.org_blog_cpp_ti-xie-p1080-guo-wang-you-hu-post]: https://www.luogu.org/blog/cpp/ti-xie-p1080-guo-wang-you-hu-post
[https_www.luogu.org_blog_league_solution-p1080]: https://www.luogu.org/blog/league/solution-p1080