国王游戏

题目描述

恰逢 H 国国庆，国王邀请 \(n\) 位大臣来玩一个有奖游戏。

首先，他让每个大臣在左、右手上面分别写下一个整数，国王自己也在左、右手上各写一个整数。

然后，让这 \(n\) 位大臣排成一排，国王站在队伍的最前面。

排好队后，所有的大臣都会获得国王奖赏的若干金币，每位大臣获得的金币数分别是:

排在该大臣前面的所有人的左手上的数的乘积除以他自己右手上的数，然后向下取整得到的结果。

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

注意，国王的位置始终在队伍的最前面。

输入格式

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

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

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

输出格式

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

数据范围

\(1≤n≤1000\)
\(0<a,b<10000\)

输入样例：

3
1 1
2 3
7 4
4 6

输出样例：

2

算法描述

不失一般性地选出其中两个相邻大臣\(i,i+1\)，他两获得的奖赏分别是

性质1：如果两相邻点满足\(a_i \times b_i \ge a_{i+1} \times b_{i+1}\)，交换后奖赏的最大值不会比之前更大，即\(max(j+1) \le max(j)\)

证明：

	i处奖赏值	i+1处奖赏值	最大奖赏值
交换前	\(\lfloor(a_1+a_2+...+a_{i-1})/b_i\rfloor\)	\(\lfloor(a_1+a_2+...+a_i)/b_{i+1}\rfloor\)	max(j)
交换后	\(\lfloor(a_1+a_2+...+a_{i-1})/b_{i+1}\rfloor\)	\(\lfloor(a_1+a_2+...+a_{i-1}+a_{i+1})/b_i\rfloor\)	max(j+1)

1.交换后i处奖赏值比交换前的i+1处奖赏值少了个\(a_i\)，因此\(交换后i处奖赏值 \le 交换前的i+1处奖赏值\)

2.由预设\(a_i \times b_i \ge a_{i+1} \times b_{i+1}\)，即\(\frac{a_i}{b_{i+1}} \ge \frac{a_{i+1}}{b_i}\)，所以\(交换后i+1处奖赏值 \le 交换前的i+1处奖赏值\)

3.所以$(max(j+1) = 交换后i处奖赏值 或 交换后i+1处奖赏值)\le 交换前i+1处奖赏值 \le max(j) $

得证

性质2：满足\(a_i \times b_i \le a_{i+1} \times b_{i+1}\)性质的方案就是最优方案

证明：

假设存在一最优方案满足\(a_i \times b_i \ge a_{i+1} \times b_{i+1}\)，那么必然可对其内部任意相邻节点进行调整，使其最终满足这个\(a_i \times b_i \le a_{i+1} \times b_{i+1}\)性质，且调整后方案的最大奖赏值不会变大。即任意最优方案都可以转化为满足这个性质的方案，所以满足这个性质的方案就是最优方案之一

总结：按照\(a_i * b_i\)进行从小到大排序，即为最优排列

代码实现

#include<iostream>
#include<algorithm>
#include<vector>

using namespace std;

typedef pair<int, int> PII;
typedef unsigned long long ULL;

const int N = 1010;
PII s[N];
int n;
vector<int> multi(vector<int> a, int b){
    int car = 0;
    vector<int> c;
    for(int i = 0; i < a.size() || car; i++){
        if(i < a.size()) car += a[i] * b;
        c.push_back(car % 10);
        car /= 10;
    }
    return c;
}

vector<int> div(vector<int> a, int b){
    reverse(a.begin(), a.end());
    int car = 0;
    vector<int> c;
    for(int i = 0; i < a.size(); i++){
        car = car * 10 + a[i];
        c.push_back(car / b);
        car %= b;
    }
    reverse(c.begin(), c.end());
    while(c.size() > 1 && c.back() == 0) c.pop_back();
    return c;
}

vector<int> max(vector<int> a, vector<int> b){
    if(a.size() != b.size()) return (a.size() > b.size() ? a:b);
    for(int i = a.size() - 1; i >= 0; i--)
        if(a[i] != b[i])
            return (a[i] > b[i] ? a : b);
    return a;
}

int main(){
    int a, b;
    cin >> n >> a >> b;
    vector<int> pre;
    while(a) pre.push_back(a % 10), a/=10;
    for(int x = 0; x < n; x++){
        cin >> a >> b;
        s[x] = {a * b, b};
    }
    sort(s, s+n);
    vector<int> ans;
    for(int x = 0; x < n; x++){
        b = s[x].second, a = s[x].first / b;
        ans = max(ans, div(pre, b));
        pre = multi(pre, a);
    }
    for(int i = ans.size() - 1; i >= 0; i--) cout << ans[i];
}