C++ Solution based on @StefanPochmann's approach with very detailed explanation
@StefanPochmann solution is great but lacks detailed comments. Here is the solution that explains the process step by step. \n    Idea - \n   K elements can be 
@StefanPochmann solution is great but lacks detailed comments. Here is the solution that explains the process step by step. \n    Idea - \n*   K elements can be picked as i elements from nums1 and k-i elements from nums2. \n*   We slice two lists nums1 and nums2 by choosing series of values for i\n*   We create biggest number possible from each list for given value of i or k-i\n*   We combine the two lists to get the biggest number for given slice.\n*   We choose maximum number for all slices.\n\nCode below - \n```\nclass Solution {\n\nprivate:\n    //Compare function for two generic collections.\n    //if collection contains non primitive types then it must overload\n    //operator \'<\'\n    \n    //returns true if second list is greater in value than first one\n    //if all elements are equal then it returns true if second list is\n    //larger in size\n    \n    template <class InputIterator1, class InputIterator2>\n      bool lexicographical_compare (InputIterator1 first1, InputIterator1 last1,\n                                    InputIterator2 first2, InputIterator2 last2)\n    {\n      while (first1!=last1)\n      {\n        if (first2==last2 || *first2<*first1) return false;\n        else if (*first1<*first2) return true;\n        ++first1; ++first2;\n      }\n      return (first2!=last2);\n    }\npublic:\n    \n    //subproblem 1 = create the greatest number with K digits from a single list\n    vector<int> maxNumber(vector<int> nums, int k) {\n        int drop = nums.size()-k; //number of digits to be dropped\n        vector<int> out;\n        for(int num : nums) {\n            //if there are digits left to be dropped and if we find\n            //a digit that is greater than the digit we have in our \n            //output array we drop the digits and add that digit\n            while(drop > 0 && out.size() != 0 && out.back() < num) {\n                drop--;\n                out.pop_back();\n            }\n            out.push_back(num);\n        }\n        out.resize(k); // this is necessary if there are more than K digits in out\n        return out;\n    }\n    \n    /*\n      subproblem 2 = create largest number from the two lists, containing\n      digits [0-9]. The size of output number is sum of size of two\n      lists\n    */\n    vector<int> maxNumber(vector<int> nums1, vector<int> nums2) {\n        auto start1 = nums1.begin(), end1 = nums1.end(),\n             start2 = nums2.begin(), end2 = nums2.end();\n        vector<int> out;\n        while(start1 != end1 || start2 != end2) {\n            if(lexicographical_compare(start1,end1,start2,end2)) {\n                out.push_back(*start2++);\n            }\n            else {\n                out.push_back(*start1++);\n            }\n        }\n        return out;\n    }\n    \n    vector<int> maxNumber(vector<int>& nums1, vector<int>& nums2, int k) {\n        int n1 = nums1.size(), n2 = nums2.size();\n        vector<int> best;\n        /* \n           The start and end range of for the "for loop" is computed based on\n           number of min elements we need to pick from nums1 and number of maximum\n           elements we can pick from nums1. if k > n2 then we must at least pick up\n           k-n2 elements from n1\n           \n           \n           Example 1\n           consider n1 = 4 and n2 = 6 and k = 5\n           Result can be constructed in following ways \n           (i:0, k-i:5), (i:1, k-i:4), (i:2, k-i:3), (i:3, k-i:2), (i:4, k-i:1)\n           where i is number of elements picked from nums1 and k-i is number of elements\n           picked from nums2. Please note\n           --> (i:5, k-i:0) is not valid since n1=4\n           \n           Example 2\n           Now consider n1 = 6 and n2 = 4 and k = 5\n           (i:1, k-i:4), (i:2, k-i:3), (i:3, k-i:2), (i:4, k-i:1), (i:5, k-i:0)\n           \n           hence starting index for i that is associated with nums1 is \n           max(0, k-n2) (in first example k-n2 = -1, in second example k-n2 = 1)\n           \n           end index for i associated with nums1 is \n           min(k,n1) (in first example i can only go up to 4 since n1 = 4, in second example\n                      i can only go up to 5 since k = 5)\n                      \n          Example 3\n          n1 = 3, n2 = 4, k = 5\n          we must pick at least 1 element from nums1 (k-n2 = 1) also i can only go up to 3 since\n          n1 is capped at 3\n          \n          Example 4\n          \n          n1 = 5, n2=3, k = 4\n          we must pick up at least 1 element from nums1 (k-n2 = 1) and i can go up to 4\n           \n        */\n          for(int i = max(0,k-n2); i <= min(k,n1); i++) {\n            \n            if(best.size() == 0) {\n                best = maxNumber(maxNumber(nums1,i),\n                                 maxNumber(nums2,k-i));\n            }\n            else {\n                vector<int> temp = maxNumber(maxNumber(nums1,i),\n                                             maxNumber(nums2,k-i));\n                if(lexicographical_compare(best.begin(), best.end(),\n                                           temp.begin(),temp.end())) {\n                    best = temp;\n                }\n            }\n            //vector class overloads "<" operator hence you could simply use the \n            //statement below, above code is only to make things simple.\n            //best = max(best,maxNumber(maxNumber(nums1,i),maxNumber(nums2,k-i)));\n        }\n        return best;\n    }    \n};\n```
[]