LeetCode 321. Create Maximum Number (分治+贪心)

题目意思：

给出两个数组，要求在这两个数组中挑出k个数，拼接起来后的数是最大的，并且同个数组的顺序需要维持。

 

解题思路：

首先先对其进行分治，我们需要取k个数，那么可以从第一个数组取 i 个贪心思路上拼起来最优的数，再到第二个数组中取 k - i 个拼起来最优的数，然后两个数组在通过贪心策略拼接到一起视为一种情况，遍历所有的 i 的情况，然后最后取最优。

贪心的策略在于分别到每个数组中取那部分最大，在代码注释中写明：

 

class Solution {
public:
    vector<int> maxNumber(vector<int>& nums1, vector<int>& nums2, int k){
        //分治+贪心
        //两个数组的大小
        int m = nums1.size(), n = nums2.size();
        //结果集
        vector<int> res;
        //如果k<m,k<n就遍历第一个数组0到m个，对应另外一个数组也遍历k-i个
        //如果k>n,那第二个数组只能遍历n个，对于第一个数组最小要遍历k-n个，第一个数组最大看情况，最多情况如果k>m则遍历m个，如果k<m则遍历k个
        if(k >= m){
            if(k <= n){
                for(int i = 0; i <= m; i++){
                    //遍历将每次的第一个数组取i个第二个数组取k-i个的情况进行比对取最大
                    vector<int> vectorA = getKMaxNums(nums1, i), vectorB = getKMaxNums(nums2, k - i);
                    //合并后的数组
                    vector<int> tmpResult;
                    while(vectorA.size() + vectorB.size() > 0){
                        //循环多次两个数组谁大（也就是谁的头大）先把谁的头取出来
                        if(vectorA > vectorB){
                            tmpResult.push_back(vectorA[0]);
                            vectorA.erase(vectorA.begin());
                        }else{
                            tmpResult.push_back(vectorB[0]);
                            vectorB.erase(vectorB.begin());
                        }
                    }
                    //和之前的情况做判断
                    res = max(res, tmpResult);
                }
            }else{
                for(int i = k-n; i <= m; i++){
                    //遍历将每次的第一个数组取i个第二个数组取k-i个的情况进行比对取最大
                    vector<int> vectorA = getKMaxNums(nums1, i), vectorB = getKMaxNums(nums2, k - i);
                    //合并后的数组
                    vector<int> tmpResult;
                    while(vectorA.size() + vectorB.size() > 0){
                        //循环多次两个数组谁大（也就是谁的头大）先把谁的头取出来
                        if(vectorA > vectorB){
                            tmpResult.push_back(vectorA[0]);
                            vectorA.erase(vectorA.begin());
                        }else{
                            tmpResult.push_back(vectorB[0]);
                            vectorB.erase(vectorB.begin());
                        }
                    }
                    //和之前的情况做判断
                    res = max(res, tmpResult);
                }
            }
        }else{
            if(k <= n){
                for(int i = 0; i <= k; i++){
                    //遍历将每次的第一个数组取i个第二个数组取k-i个的情况进行比对取最大
                    vector<int> vectorA = getKMaxNums(nums1, i), vectorB = getKMaxNums(nums2, k - i);
                    //合并后的数组
                    vector<int> tmpResult;
                    while(vectorA.size() + vectorB.size() > 0){
                        //循环多次两个数组谁大（也就是谁的头大）先把谁的头取出来
                        if(vectorA > vectorB){
                            tmpResult.push_back(vectorA[0]);
                            vectorA.erase(vectorA.begin());
                        }else{
                            tmpResult.push_back(vectorB[0]);
                            vectorB.erase(vectorB.begin());
                        }
                    }
                    //和之前的情况做判断
                    res = max(res, tmpResult);
                }
            }else{
                for(int i = k-n; i <= k; i++){
                    //遍历将每次的第一个数组取i个第二个数组取k-i个的情况进行比对取最大
                    vector<int> vectorA = getKMaxNums(nums1, i), vectorB = getKMaxNums(nums2, k - i);
                    //合并后的数组
                    vector<int> tmpResult;
                    while(vectorA.size() + vectorB.size() > 0){
                        //循环多次两个数组谁大（也就是谁的头大）先把谁的头取出来
                        if(vectorA > vectorB){
                            tmpResult.push_back(vectorA[0]);
                            vectorA.erase(vectorA.begin());
                        }else{
                            tmpResult.push_back(vectorB[0]);
                            vectorB.erase(vectorB.begin());
                        }
                    }
                    //和之前的情况做判断
                    res = max(res, tmpResult);
                }
            }
        }
        return res;
    }
    vector<int> getKMaxNums(vector<int> nums, int k){
        int s = nums.size();
        //扔掉size - k个
        int dropCount = s - k;
        vector<int> res;
        //贪心策略：遍历每个，当前数比结果集末位大的替换，因为对于结果集末位这一位数肯定是越大越好，根据思路：越高位越大数越大
        for(int i = 0; i < s; i++){
            while(dropCount && res.size() && res.back() < nums[i]){
                //扔掉小的那个
                res.pop_back();
                -- dropCount;
            }
            res.push_back(nums[i]);
        }
        res.resize(k);
        return res;
    }
};