题目描述
恰逢 H 国国庆，国王邀请
n
n
n 位大臣来玩一个有奖游戏。首先，他让每个大臣在左、右手上面分别写下一个整数，国王自己也在左、右手上各写一个整数。然后，让这
n
n
n 位大臣排成一排，国王站在队伍的最前面。排好队后，所有的大臣都会获得国王奖赏的若干金币，每位大臣获得的金币数分别是：排在该大臣前面的所有人的左手上的数的乘积除以他自己右手上的数，然后向下取整得到的结果。
国王不希望某一个大臣获得特别多的奖赏，所以他想请你帮他重新安排一下队伍的顺序，使得获得奖赏最多的大臣，所获奖赏尽可能的少。注意，国王的位置始终在队伍的最前面。
输入格式
第一行包含一个整数
n
n
n，表示大臣的人数。
第二行包含两个整数
a
a
a 和
b
b
b，之间用一个空格隔开，分别表示国王左手和右手上的整数。
接下来
n
n
n 行，每行包含两个整数
a
a
a 和
b
b
b，之间用一个空格隔开，分别表示每个大臣左手和右手上的整数。
输出格式
一个整数，表示重新排列后的队伍中获奖赏最多的大臣所获得的金币数。
样例 #1
样例输入 #1
3
1 1
2 3
7 4
4 6
样例输出 #1
2
提示
【输入输出样例说明】
按
1
1
1、
2
2
2、
3
3
3 这样排列队伍，获得奖赏最多的大臣所获得金币数为
2
2
2；
按
1
1
1、
3
3
3、
2
2
2 这样排列队伍，获得奖赏最多的大臣所获得金币数为
2
2
2；
按
2
2
2、
1
1
1、
3
3
3 这样排列队伍，获得奖赏最多的大臣所获得金币数为
2
2
2；
按$ 2$、
3
3
3、$1 $这样排列队伍，获得奖赏最多的大臣所获得金币数为
9
9
9；
按
3
3
3、
1
1
1、$2 $这样排列队伍，获得奖赏最多的大臣所获得金币数为
2
2
2；
按$ 3$、
2
2
2、
1
1
1 这样排列队伍，获得奖赏最多的大臣所获得金币数为
9
9
9。
因此，奖赏最多的大臣最少获得
2
2
2 个金币，答案输出
2
2
2。
【数据范围】
对于
20
%
20\%
20% 的数据，有
1
≤
n
≤
10
,
0
<
a
,
b
<
8
1≤ n≤ 10,0 < a,b < 8
1≤n≤10,0<a,b<8；
对于
40
%
40\%
40% 的数据，有$ 1≤ n≤20,0 < a,b < 8$；
对于
60
%
60\%
60% 的数据，有
1
≤
n
≤
100
1≤ n≤100
1≤n≤100；
对于
60
%
60\%
60% 的数据，保证答案不超过
1
0
9
10^9
109；
对于
100
%
100\%
100% 的数据，有
1
≤
n
≤
1
,
000
,
0
<
a
,
b
<
10000
1 ≤ n ≤1,000,0 < a,b < 10000
1≤n≤1,000,0<a,b<10000。
解题思路：
先不考虑如何使最大值尽可能的小，只针对某一位固定的大臣
为了使这位大臣所获得的金币数最少，我们希望他前面所有人左手上的数乘积尽可能的小，同时这位大臣右手上的数尽可能的大
要使乘积尽可能的小，需要使乘数尽可能的少、使排队的人左手上的数尽可能的小
所以现在有三个目的：该大臣前面的人数尽可能的少，前面的人左手上的数尽可能的小，他右手上的数尽可能的大
以上三条就是减少一位大臣获得奖赏的所有方法
然后我们来考虑如何使最大值尽可能的小
对于第一条，只需要让最大值站在国王后面就可以了，但这显然不合理
对于第二条，前面的人左手上的数尽可能的小，可以说就是后面的人左手上的数尽可能的大
也就是说左手数越大的大臣，我们偏向于让他站在后面
对于第三条，我们偏向于让右手数越大的大臣站在越后面
那么是不是左右手乘积越大站在越后面就行了呢？接下来进行证明
现假设有n位大臣，编号分别为
p
1
,
p
2
,
…
,
p
n
p_1,p_2,\dots,p_n
p1,p2,…,pn，其中获得奖赏最多的为
p
k
(
1
≤
k
≤
n
)
p_k(1 \leq k \leq n)
pk(1≤k≤n)
要使max减少，需要进行位置交换，假设将
p
i
,
p
j
(
1
≤
i
≤
k
≤
j
≤
n
,
i
≠
j
)
p_i,p_j(1 \leq i \leq k \leq j \leq n,i \ne j)
pi,pj(1≤i≤k≤j≤n,i=j)进行交换可以使max减少
可以看到，对于所有
p
i
p_i
pi之前和
p
j
p_j
pj之后的大臣，其获得的金币数不受影响
设左手数数组、右手数数组分别为left[n + 1],right[n + 1]
接下来分类讨论三种情况
（1）i != k && j != k
由于
p
k
p_k
pk的右手数不会改变，前方人数不变，max减少一定是因为第二条
可以看到，
p
i
+
1
p_{i+1}
pi+1~
p
j
−
1
p_{j-1}
pj−1所获得的奖赏均减少
同时由于
p
j
p_j
pj的右手数不变，且因为第一条，所以
p
j
p_j
pj获得金币数减少
要使max减少，只需要使
p
i
≤
m
a
x
p_i \leq max
pi≤max或
p
k
p_k
pk即可
可以推导出
n
e
w
p
i
=
l
e
f
t
1
∗
⋯
∗
l
e
f
t
j
−
1
∗
l
e
f
t
j
l
e
f
t
i
r
i
g
h
t
j
∗
r
i
g
h
t
i
r
i
g
h
t
j
=
o
l
d
p
j
∗
l
e
f
t
j
∗
r
i
g
h
t
j
l
e
f
t
i
∗
r
i
g
h
t
i
newp_i = \frac{left_1* \dots *left_{j-1}* \frac{left_j}{left_i}}{right_j* \frac{right_i}{right_j}} = oldp_j * \frac{left_j * right_j}{left_i * right_i}
newpi=rightj∗rightjrightileft1∗⋯∗leftj−1∗leftileftj=oldpj∗lefti∗rightileftj∗rightj（注：这个式子除了
i
<
j
i < j
i<j之外没有任何限制）
若有
p
i
p_i
pi左右手乘积更大，则有
n
e
w
p
i
<
o
l
d
p
j
≤
m
a
x
newp_i < oldp_j \leq max
newpi<oldpj≤max
（2）i == k && j != k
由于
p
k
p_k
pk的右手数不会改变，前方大臣左手数乘积增大，显然不可能使max减小
（3）i != k && j == k
显然max减少是因为第一条，有
r
i
g
h
t
k
>
r
i
g
h
t
i
right_k > right_i
rightk>righti
由（1）式子可得，如果
p
i
p_i
pi的左右手乘积更大，
n
e
w
p
i
<
o
l
d
p
k
≤
m
a
x
newp_i < oldp_k \leq max
newpi<oldpk≤max
若
l
e
f
t
k
≤
l
e
f
t
i
left_k \leq left_i
leftk≤lefti，则
p
i
+
1
p_{i+1}
pi+1~
p
k
−
1
p_{k-1}
pk−1所获得的的奖赏均减少，故max减少了
若
l
e
f
t
k
>
l
e
f
t
i
left_k > left_i
leftk>lefti，显然
p
k
p_k
pk的左右手乘积更大，不能和
p
i
p_i
pi交换
至此，证明完毕
接下来是代码的实现，注意可能会出现
100
0
9999
1000^{9999}
10009999故需要使用高精度
#include <iostream>
#include <algorithm>
#include <iomanip>
using namespace std;
const size_t bits = 10;
const int64_t mod_num = 10000000000;
struct person {
int left;
int right;
};
person queue[1001];
int64_t num[2][10000] = { {1},{1} };
int64_t max_num[10000] = { 0 };
int max_len = 0;
int main() {
int n, highest = 0;
cin >> n;
for (int i = 0; i <= n; i++)
cin >> queue[i].left >> queue[i].right;
sort(queue + 1, queue + n + 1, [](person p_1, person p_2) {
return p_1.left * p_1.right < p_2.left * p_2.right;
});
for (int i = 1; i <= n; i++) {
num[(i + 1) % 2][0] = int64_t(queue[i - 1].left) * num[i % 2][0];
int j = 1;
while (j <= highest + 1)
{
num[(i + 1) % 2][j] = int64_t(queue[i - 1].left) * num[i % 2][j];
num[(i + 1) % 2][j] += num[(i + 1) % 2][j - 1] / mod_num;
num[(i + 1) % 2][j - 1] %= mod_num;
j++;
}
while (j > 0 && num[(i + 1) % 2][j] == 0) j--;
highest = j;
int z = j;
int64_t upper = 0, lower = 0;
while (z >= 0) {
upper = (num[(i + 1) % 2][z] + lower) / int64_t(queue[i].right);
lower = (num[(i + 1) % 2][z] + lower) % int64_t(queue[i].right) * mod_num;
if (upper > max_num[z]) {
max_len = j;
lower = 0;
while (j >= 0) {
upper = (num[(i + 1) % 2][j] + lower) / int64_t(queue[i].right);
lower = (num[(i + 1) % 2][j] + lower) % int64_t(queue[i].right) * mod_num;
max_num[j] = upper;
j--;
}
break;
}
else if (upper == max_num[z]) {
z--;
continue;
}
else break;
}
}
cout << max_num[max_len];
while (--max_len >= 0) cout << setiosflags(ios::right) << setfill('0') << setw(bits) << max_num[max_len];
}
我的高精度稍微改了一下，不想看的这段可以直接跳过
改动的第一个地方就是把10进制改成了1e10进制
这样好处就是可以把大臣手上的数看成一位（因为一定小于1e10），并减少循环次数
需要做出的改变就是模数由10变为1e10，在输出的时候要格式化一下
改动的第二个地方就是使用两个高精度数字进行高精度乘法（也就是%2的意义，i每改变奇偶性一次，乘积和乘数交换一次）
这样好处就是节约了空间
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)
