最大化被两行相同索引元素最大值生成的数组的最小值

给定一个矩阵，我们可以从中选择两行，使得这两行的相同索引元素的最大值生成一个新的数组。现在我们的任务是要最大化这个新数组的最小值。

解决方案

这是一个优化问题，通过对矩阵元素进行二分搜索，我们可以找到最大化新数组最小值的最小值。接着，我们可以使用贪心算法，检查是否存在两行，使得它们生成的新数组的最小值大于等于这个最小值。如果存在，我们开始缩小二分搜索的范围，直到找到最小值。

思路如下：

1. 对矩阵进行二分搜索，设定左右边界 l 和 r。l 初始值为 0，r 初始化为矩阵中元素的最大值。
2. 计算 mid = (l+r)/2，检查是否存在两行，使得它们生成的新数组的最小值大于等于 mid。
3. 如果存在，则我们可以缩小范围，l=mid+1，否则 r=mid-1。
4. 当左右边界重合时，返回 l。

接下来，我们需要一个方法来检查是否存在两行，使得它们生成的新数组的最小值大于等于 mid。在实现该方法时，我们可以使用双指针算法。

算法：

1. 对于每一列 j，我们都会在两行 i 和 k 中查找元素。首先，我们设置两个指针分别指向 i 和 k 的第一列：p1=0 和 p2=0。
2. 然后，我们将 p2 向右移动，直到满足 matrix[i][p1] <= matrix[k][p2] 或者 p2 达到最后一列。
3. 如果 matrix[i][p1] == matrix[k][p2]，则我们找到了一对符合条件的行。
4. 如果 matrix[i][p1] > matrix[k][p2]，则我们将 p1 向右移动。
5. 如果 matrix[i][p1] < matrix[k][p2]，则我们将 k 向下移动。

重复上述步骤，直到我们找到一对符合条件的行，或者无法找到这样的行。

实现该算法后，我们只需将它嵌入到二分搜索中即可。具体实现请参见下面的代码。

代码实现

from typing import List

class Solution:
    def max_min_generated_array(self, matrix: List[List[int]]) -> int:
        n = len(matrix)
        m = len(matrix[0])
        
        def check(mid):
            for i in range(n):
                for j in range(i+1, n):
                    p1 = p2 = 0
                    while p2 < m and matrix[i][p1] < mid:
                        p1 += 1
                        if p1 == m:
                            return False
                        while p2 < m and matrix[i][p1] > matrix[j][p2]:
                            p2 += 1
                        if p2 == m:
                            break
                        if matrix[i][p1] == matrix[j][p2]:
                            break
                    if p2 == m:
                        return False
            return True
        
        l, r = 0, max(max(row) for row in matrix)
        ans = 0
        while l <= r:
            mid = (l+r) // 2
            if check(mid):
                ans = mid
                l = mid + 1
            else:
                r = mid - 1
        
        return ans

复杂度分析

• 时间复杂度：使用二分搜索的时间复杂度为 O(log(max(matrix)))，每次检查两行的时间复杂度为 O(m)，因此总时间复杂度为 O(mn log(max(matrix)))。
• 空间复杂度：使用常数级别的额外空间。