5.3 国王的游戏（贪心，高精度）

来源：NOIP2012提高组 https://ac.nowcoder.com/acm/contest/260/E

恰逢 H 国国庆，国王邀请 n 位大臣来玩一个有奖游戏。首先，他让每个大臣在左、右手上面分别写下一个整数，国王自己也在左、右手上各写一个整数。然后，让这 n 位大臣排成一排，国王站在队伍的最前面。排好队后，所有的大臣都会获得国王奖赏的若干金币，每位大臣获得的金币数分别是：排在该大臣前面的所有人的左手上的数的乘积除以他自己右手上的数，然后向下取整得到的结果。
国王不希望某一个大臣获得特别多的奖赏，所以他想请你帮他重新安排一下队伍的顺序，使得获得奖赏最多的大臣，所获奖赏尽可能的少。注意，国王的位置始终在队伍的最前面。
输入描述:
第一行包含一个整数 n ，表示大臣的人数。
第二行包含两个整数 a 和 b ，之间用一个空格隔开，分别表示国王左手和右手上的整数。
接下来 n 行，每行包含两个整数 a 和 b ，之间用一个空格隔开，分别表示每个大臣左手和右手上的整数。

输出描述:
一个整数，表示重新排列后的队伍中获奖赏最多的大臣所获得的金币数。
示例1
输入
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%的数据，保证答案不超过 109 ；
对于 100%的数据，有 1 ≤ n ≤1,000,0 ＜ a,b ＜ 10000 。

题解：本题不能用最普通的做法，因为数字太长，几百位，所以得用高精度来做，用vector来存储每一位数字。

高精度模板：https://blog.csdn.net/qq_43590403/article/details/98651050

做法：直接将所有大臣按左右手上的数的乘积从小到大排序，得到的序列就是最优排队方案。

证明：

假设不是按照左右手乘积从小到大排序。
我们记第 i 个大臣左手上的数是 A_i，右手上的数是 B_i;
则：一定存在两个相邻的人，满足 A_i * B_i >= A_i + 1 * B_i + 1

交换后： A_i + 1 * B_i + 1 ------------------ A_i * B_i

现在我们将两人位置交换，得到结果：
交换前：第i个人是：A_0 * …A_i- 1 / B_i 第i+1个人是 A_0 * …A_i / B_i+1
交换后：第i个人是：A_0 * …A_i- 1 * A_i+1 / B_i 第i+1个人是 A_0 * …A_i -1/ B_i+1

化简一下：
前： 1/B_i ----------------------------- A_i / B_i+1----------------最大值为：A_i / B_i+1
后： A_i+1 / B_i --------------------- 1/ B_i+1--------------------最大值为：A_i+1 / B_i和1/ B_i+1取max

很明显：交换后的两个数字一定是 <= 交换前，而且交换相邻两人不会对其他人产生影响，所以若存在逆序就进行交换，一定比交换前结果更优。

所以左右手乘积从小到大排序为最优解。

#include <cstdio>
#include <queue>
#include <stack>
#include <cstdio>
#include <string>
#include <iostream>
#include <algorithm>

const int N = 1010;

using namespace std;
pair<int,int> person[N];
typedef vector<int> V;

//高精度乘法multiplication
// C = A * b, A >= 0, b > 0
V mul(V a, int b)
{
    V C;
    int t = 0;
    for (int i = 0; i < a.size() || t; i ++ )
    {
        if (i < a.size()) t += a[i] * b;
        C.push_back(t % 10);
        t /= 10;
    }
    return C;
}
//高精度除法division
// A / b = C ... r, A >= 0, b > 0
V div(V a, int b)
{
    vector<int> C;
    int r = 0;
    //从前往后除，存储的顺序是正的
    for (int i = a.size() - 1; i >= 0; i -- )
    {
        r = r * 10 + a[i];
        C.push_back(r / b);
        r %= b;
    }
    //反转后是为了把一开始除的时候存储的 ‘0’放到末尾，便于删除
    reverse(C.begin(), C.end());
    //除去末尾 ‘0’，此时结果为倒序
    while (C.size() > 1 && C.back() == 0) C.pop_back();
    //倒序输出
    return C;
}
//高精度比较
bool cmp(V a, V b)
{
    //若两个数字长度不同，a小，则返回true
    if(a.size() != b.size()) return a.size() < b.size();
    //若长度相同，反转一下，直接比较，vector自动比较
    reverse(a.begin(), a.end());
    reverse(b.begin(), b.end());
    //vector 按照字典序比较
    return a < b;
}

//高精度倒序输出
void out(V res)
{
    for(int i = res.size() - 1; i >= 0; i--) cout<<res[i];
    cout<<endl;
}

int main()
{
    int n;
    cin>>n;
    for(int i = 0; i <= n; i++)
    {
        int a,b;
        cin>>a>>b;
        person[i] = make_pair(a*b, a);
    }
    //按 a*b 从小到大排序，不排国王
    sort(person + 1, person + 1 + n);

    V res(1,0);//结果,默认为 0
    V p(1, 1);//记录累乘的结果，默认为 1 开始

    for(int i = 0; i <= n; i++)
    {
        int a = person[i].second, b = person[i].first / a;
        //从 1 开始开始进入每次的除法
        if(i > 0)
        {
            //累除，从第一位士兵开始
            V t = div(p, b);
            //每次比较当前最大，更新res
            if(cmp(res,t)) res = t;
        }
        //累乘 p从1开始
        p = mul(p, a);
    }
    
    //倒序输出
    out(res);

    return 0;
}