leetcode 870. 优势洗牌（田忌赛马问题）

分析

主要是是一个贪心问题，先对A进行排序，每次在A中寻找大于B[i]的最小值，若没有，则返回A中的最小值。

multiset的作用

维持一个有可重复的有序的set, 方便查找和动态删除，且删除之后仍然是有序的。

方法1

class Solution {
public:
    vector<int> advantageCount(vector<int>& A, vector<int>& B) {
        vector<int> res;
        multiset<int> ans_A;
        if(A.size()==0) return res;
        //将A放到一个multiset中
        for(int i=0;i<A.size();i++) ans_A.insert(A[i]);
        for(int i=0;i<B.size();i++){
            bool flag = false;      
            //遍历ans_A
            for(auto it = ans_A.begin();it!=ans_A.end();it++){
                if(*it>B[i]){
                    res.push_back(*it);
                    ans_A.erase(it);
                    flag = true;
                    break;
                }
            }  
            if(!flag){
                res.push_back(*ans_A.begin()); 
                ans_A.erase(ans_A.begin());
            }
        }
        return res;
    }
};

方法2：

上面的方法是超时的，考虑使用标记数组的方式。虽然是多过了几个用例仍是超时。

class Solution {
public:
    vector<int> advantageCount(vector<int>& A, vector<int>& B) {
        vector<int> res;
        if(A.size()==0) return res;
        //对A进行排序
        sort(A.begin(), A.end());
        vector<int> f(A.size(), 0);
        int index = 0;//表示已经使用的A的较小值的索引结尾
        for(int i=0;i<B.size();i++){
            bool flag = false;      
            //遍历ans_A
            for(int j=0;j<A.size();j++){//j也可以从index开始
                if(A[j]>B[i] && !f[j]){
                    res.push_back(A[j]);
                    flag = true;
                    f[j] = 1;
                    break;
                }
            }  
            if(!flag){
                while(f[index]) index++;
                f[index] = 1;
                res.push_back(A[index++]); 
            }
        }
        return res;
    }
};

方法3：

不使用multiset, 使用vector+ 二分查找+erase删除元素。为什么不使用multiset+二分查找，主要是因为multiset不支持顺序迭代器访问，因此在使用二分查找之后，不好进行删除元素。

class Solution {
public:
    int binary_search(vector<int>& arr, int target){
        int l = 0;
        int r = arr.size();
        while(l<r){
            int mid = l + (r-l)/2;
            int mid_value = arr[mid];
            if(mid_value<=target){//找第一个比target大的
                l = mid+1;
            }else r = mid;
        }
        return l;
    }
    vector<int> advantageCount(vector<int>& A, vector<int>& B) {
        vector<int> res;
        if(A.size()==0) return res;
        sort(A.begin(), A.end());
        for(int i=0;i<B.size();i++){
            int l = binary_search(A, B[i]);
            if(l==A.size()){//没有找到
                res.push_back(*A.begin()); 
                A.erase(A.begin());
            }
            if(l<A.size()){
                res.push_back(A[l]);
                A.erase(A.begin()+l);
            }
        }
        return res;
    }
};