两个给定数组的子序列可能的最大 K 位数

给定两个长度为M和N 的数组arr1[]和arr2[]由表示两个数字的数字[0, 9]和一个整数 K ( K ≤ M + N ) 组成，任务是找到可能的最大 K 位数字通过从给定数组中选择子序列，使得数字的相对顺序与给定数组中的相同。

例子：

Input: arr1[] = {3, 4, 6, 5}, arr2[] = {9, 1, 2, 5, 8, 3}, K = 5
Output: 98653
Explanation: The maximum number that can be formed out of the given arrays arr1[] and arr2[] of length K is 98653.

Input: arr1[] = {6, 7}, arr2[] = {6, 0, 4}, K = 5
Output: 67604
Explanation: The maximum number that can be formed out of the given arrays arr1[] and arr2[] of length K is 67604.

朴素的方法：想法是从arr1[]生成所有长度为s1 的子序列，并从数组arr2[] 中生成所有长度为(K – s1) 的子序列，覆盖范围[0, K]内 s1 的所有值，并跟踪通过在每次迭代中合并两个数组而形成的最大数量。

时间复杂度： O(2 ^N )
辅助空间： O(1)

有效的方法：为了优化上述方法，想法是从数组arr1[]和长度s1 中获取最大数，从数组arr2[]和长度(K – s1) 中获取最大数。然后，合并两个数组以获得长度K的最大数量。请按照以下步骤解决给定的问题：

1. 使用变量i在范围[0, K] 上迭代并生成所有可能的长度为i 的递减子序列，保留与数组 arr1[] 中相同的顺序，并且长度(K – i)的子序列遵循与数组中相同的顺序arr2[] 。
2. 要在上述步骤中生成任何数组arr[]的长度为 L的递减子序列，请执行以下操作：
   • 初始化一个数组ans[]以存储长度为L的子序列，保留与 arr[] 中相同的顺序，并遍历数组arr[]并执行以下操作：
     • 直到最后一个元素小于当前元素，然后从数组ans[] 中删除最后一个元素。
     • 如果 ans[]的长度小于L则将当前元素插入ans[] 。
   • 经过上述步骤后，结果子序列中的数组 ans[] 。
3. 同时使用在步骤2中讨论的方法产生在步骤1中所有可能长度的子序列通过合并所形成的两个子信号串产生的最大数量。
4. 完成上述步骤后，打印合并后给出最大数量的子序列。

下面是上述方法的实现：

Python3

# Python program for the above approach
  
# Function to find maximum K-digit number
# possible from subsequences of the
# two arrays nums1[] and nums2[]
def maxNumber(nums1, nums2, k):
  
    # Store lengths of the arrays
    l1, l2 = len(nums1), len(nums2)
  
    # Store the resultant subsequence
    rs = []
  
    # Function to calculate maximum 
    # number from nums of length c_len
    def helper(nums, c_len):
            
        # Store the resultant maximum
        ans = []  
          
        # Length of the nums array
        ln = len(nums)
          
        # Traverse the nums array
        for idx, val in enumerate(nums):
            while ans and ans[-1] < val and ln-idx > c_len-len(ans):
                  
                # If true, then pop
                # out the last element
                ans.pop(-1)  
                  
            # Check the length with
            # required length
            if len(ans) < c_len: 
                    
                # Append the value to ans
                ans.append(val)
                  
        # Return the ans
        return ans  
  
    # Traverse and pick the maximum
    for s1 in range(max(0, k-l2), min(k, l1)+1):
        
        # p1 and p2 stores maximum number possible
        # of length s1 and k - s1 from
        # the arrays nums1[] & nums2[]
        p1, p2 = helper(nums1, s1), helper(nums2, k-s1)
          
        # Update the maximum number
        rs = max(rs, [max(p1, p2).pop(0) for _ in range(k)])
      
    # Return the result
    return rs  
  
  
# Driver Code
  
arr1 = [3, 4, 6, 5]
arr2 = [9, 1, 2, 5, 8, 3]
  
K = 5
  
# Function Call
print(maxNumber(arr1, arr2, K))

输出：

[9, 8, 6, 5, 3]

时间复杂度： O(K*(M + N))
辅助空间： O(K)

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。