一个人在两个方向排成一排时能看到的最大人数

在这个主题中，我们要求解一个非常有趣的问题——

一个人站在一个直线上，他的左边和右边都有无数个人，但是站在同一个位置的人彼此之间会遮挡，即只能看到前面的人。 那么，这个人在两个方向看到的最大人数是多少？

接下来，我们将使用两种不同的算法来解决这个问题。让我们开始吧！

算法一：暴力破解法

首先，我们可以尝试用一个暴力的方法来解决这个问题。具体来说，我们可以对于每个位置，分别向左和向右扫描整个序列，并计算出该位置向两个方向所能看到的人数。

下面是使用 Python 代码实现的这个算法：

def max_people(n, a):
    ans = 0
    for i in range(n):
        l = r = i
        while l >= 0 and a[l] <= a[i]:
            l -= 1
        while r < n and a[r] <= a[i]:
            r += 1
        ans = max(ans, r - l - 1)
    return ans

其中，n 表示序列的长度，a 是一个长度为 n 的整数序列，表示站在每个位置上的人的身高。我们首先将 ans 初始化为 0，然后对于每个位置 i，分别向左和向右扫描序列，直到找到第一个比当前位置上的人矮的人为止。

最后，我们将向左和向右所能看到的人数相加，并将结果更新为 ans。

这个算法的时间复杂度为 $O(n^2)$，对于较小的输入规模可以通过本题。然而，当输入规模较大时，这个算法的效率会变得非常低下。因此，我们需要考虑一个更加高效的解法。

算法二：单调栈优化法

接下来，我们将介绍一种更高效的算法，这个算法的时间复杂度为 $O(n)$。

我们将使用单调栈来实现这个算法。具体来说，我们维护一个单调递减的栈，其中每个元素代表一个人在序列中的位置。从左到右扫描整个序列，对于每个位置，我们都将这个位置作为一个入栈元素，并检查栈顶元素是否能被看到。

如果栈顶元素不能被看到，那么我们可以将其从栈中弹出；否则，我们将当前位置加到栈中。对于向右的方向，我们将序列翻转之后采用相同的方法进行处理，即维护一个单调递减的栈。

下面是使用 Python 代码实现的这个算法：

def max_people(n, a):
    ans = 0
    stk = []
    for i in range(n):
        while stk and a[stk[-1]] <= a[i]:
            stk.pop()
        l = stk[-1] + 1 if stk else 0
        ans = max(ans, i - l + 1)
        stk.append(i)

    stk = []
    for i in range(n - 1, -1, -1):
        while stk and a[stk[-1]] <= a[i]:
            stk.pop()
        r = stk[-1] - 1 if stk else n - 1
        ans = max(ans, r - i + 1)
        stk.append(i)

    return ans

其中，n 和 a 的含义与上述算法一致。我们首先将 ans 初始化为 0，然后定义一个栈 stk，用于维护当前位置向左和向右所能看到的最远距离。

对于向左的方向，我们首先将当前位置加入栈中，并检查栈顶元素是否能被看到。如果栈顶元素不能被看到，那么我们可以将其从栈中弹出；否则，我们计算出向左所能看到的最远位置 l，并将其更新为 ans。

对于向右的方向，我们将序列翻转之后使用相同的方法。由于这个过程中会改变我们的栈的内容，因此我们需要重新定义一个栈 stk。

最终，将向左和向右所能看到的人数相加，并将结果返回为 ans。

总结

在本文中，我们介绍了两种不同的算法来解决一个人在两个方向排成一排时能看到的最大人数的问题。第一种算法是暴力破解法，时间复杂度为 $O(n^2)$。第二种算法是单调栈优化法，时间复杂度为 $O(n)$。对于较小的输入规模可以使用第一种算法，但对于较大的输入规模必须使用第二种算法。