leetcode. 870. Advantage Shuffle (优势洗牌)

题目:

给定两个大小相等的数组 A 和 B，A 相对于 B 的优势可以用满足 A[i] > B[i] 的索引 i 的数目来描述。

返回 A 的任意排列，使其相对于 B 的优势最大化。

 

示例 1：

输入：A = [2,7,11,15], B = [1,10,4,11]
输出：[2,11,7,15]

示例 2：

输入：A = [12,24,8,32], B = [13,25,32,11]
输出：[24,32,8,12]

 

提示：

1. 1 <= A.length = B.length <= 10000
2. 0 <= A[i] <= 10^9
3. 0 <= B[i] <= 10^9

分析：

      这道题，按照题目意思，很明显就是全排列，找到最大的优势，小编第一次做的时候，被带跑偏了，然后写出来全排列，结果超时了。

      结果又想了想，我们可以使用贪心的做法，就是把A中第一大的数对上B中刚好小于这个数的数，依次类推，至于后面A中比B中小的数，无所谓排列。

证明：

      田忌赛马的典故大家都知道，为什么田忌赢得了比赛，就是田忌拿最弱的马让对手最优的马比赛，因此我们反其道而行之，每次都拿最优的马和对手刚好比我最优马弱一点的马比，这样才能创造最大的优势。

方法一： 全排列的做法（超出时间限制）

class Solution {
public:
    vector<int> advantageCount(vector<int>& A, vector<int>& B) {
        int cnt = 0;
        vector<int> ret = A;
        int len = A.size();
        dfs(A,0,len,B,cnt, ret);
        return ret;
    }
    
    void dfs(vector<int> & A, int i, int len, vector<int> &B, int &cnt, vector<int> &ret){
        if(i == len){
            int count = 0;
            for(int k = 0; k < len ;k++){
                if(A[k] > B[k])
                    count++;
            }
            if(count>cnt){
                cnt = count;
                ret = A;
            }
            return;
        }
        else{
            for(int j = i ; j < len; j++){
                swap(A[j], A[i]);
                dfs(A, i+1, len, B,cnt,ret);
                swap(A[j], A[i]);
            }
        }
    }

};

方法二：田忌赛马法 (注意，要把值和坐标绑在一起，排序为升序排列，也就是从最弱的马开始找）

class Solution {
public:
    static int cmp(pair<int,int> A, pair<int, int> B){
        return A.first < B.first;
    }
    vector<int> advantageCount(vector<int>& A, vector<int>& B) {
        int len = A.size();
        vector<pair<int, int>> pairA, pairB;
        for(int i = 0; i < len; i++){
            pairA.push_back(pair<int, int>(A[i], i));
            pairB.push_back(pair<int, int>(B[i], i));
        }
        sort(pairA.begin(), pairA.end(), cmp);
        sort(pairB.begin(), pairB.end(), cmp);
        vector<int> ret(len,-1);
        vector<int> tmp;
        int i = 0, j = 0;
        while(i < len && j < len){
            if(pairA[i].first > pairB[j].first){
                ret[pairB[j].second] = pairA[i].first;
                i++;
                j++;
            }
            else{
                tmp.push_back(pairA[i].first);
                i++;
            }
        }
        for(int i = 0; i < len; i++){
            if(ret[i] == -1){
                ret[i] = tmp.back();
                tmp.pop_back();
            }
        }
        return ret;
    }
};