Algorithm 查找非固定长度x的每个子阵列的最小值的最大值，其中1<；=x<；=N

面试问题：

数组中有N个数字。一组数字是数组的非空连续段。组的大小是该组中的数字数

---

设A为组中的最小数。任务是为每个x（1查找这个问题只是使用了一些花哨的词。您只需要计算反向排序数组中的第（x-1）个最大数

要查看这一点，假设您有一个如下形式的数组：

A = [12, 14, 26, 50, 43];

如果你把它分类，它就会变成

A' = [12, 14, 26, 43, 50];

现在，任何需要最大化最小值的子阵列，从末端开始时都将是长度为x的子阵列。因为对于所有其他可能的子阵列，必须存在小于末端第x个元素的元素，从而减小最小值

所以要得到答案，只需对数组进行反向排序，索引（x-1）处的元素就是答案

A'' = [50, 43, 26, 14, 12]

非固定长度x的每个子阵的最小值的最大值可以很容易地计算出来

编辑：

例如，请参见从1到3的x

 Length 1: 50
 Length 2: 43
 Length 3: 26

等等

EDIT2:

只有在所有元素都是唯一的情况下，这才有效。

这是一种O（n2）溶液

将输出数组设置为空，将输入数组a设置为初始值

当a为非空时：

• 计算添加到输出数组开头的最大值
• 在上执行收缩操作，其中每个元素a[i]设置为a[i]和a[i+1]中的最小值，并移除最后一个元素

例如：

output = []
a = [1,2,3,4,5,4,6]
output = [6] // add max of a to start of output array
a = [1,2,3,4,4,4]  // shrink array
output = [4,6] // add max of a to start of output array
a = [1,2,3,4,4]  // shrink array
output = [4,4,6] // add max of a to start of output array
a = [1,2,3,4]  // shrink array
output = [4,4,4,6] // add max of a to start of output array
a = [1,2,3]  // shrink array
output = [3,4,4,4,6] // add max of a to start of output array
a = [1,2]  // shrink array
output = [2,3,4,4,4,6] // add max of a to start of output array
a = [1]  // shrink array
output = [1,2,3,4,4,4,6] // add max of a to start of output array
a = []

在循环的第一次迭代开始时，a将包含长度为1的所有组的最小值（仅初始值）。在第二次迭代开始时，a将包含长度为2的所有组的最小值，依此类推

在每次迭代中，元素a[i]到a[j]（min（a[i]…a[j]）的最小值将等于

min（min（a[i]…a[j-1]），min（a[i+1]…a[j]））

因此，您可以根据长度为n-1的相邻组计算长度为n的组的最小值

C代码：

#include <stdio.h>

int main() {
    int a[] = {6,1,3,2,5,4,7};
    size_t i, N = sizeof a / sizeof *a;

    for (i=0; i<N; ++i) printf("%d ", a[i]); puts("\n");

    while(N > 0)
    {
        int max = a[0];
        for(i = 0; i < N - 1; i++)
        {
            if(a[i+1] > max)
               max = a[i+1];
            a[i] = a[i+1] < a[i] ? a[i+1] : a[i];
        }
        printf("%d ", max);
        N--;
    }

    return 0;
}

#包括
int main（）{
int a[]={6,1,3,2,5,4,7}；
尺寸i，N=a的尺寸/a的尺寸；
对于（i=0；i=0）
{
int max=a[0]；
对于（i=0；i最大值）
max=a[i+1]；
a[i]=a[i+1]

---

线性时间解决方案的非常简短的草图：对于每个数组元素，计算该元素最小的最大组的大小。（通过将两个相等元素中的第一个视为较小元素来打破联系。）使用退化桶排序，在线性时间内按其关联大小对元素进行排序。按大小从大到小扫描元素，输出迄今为止看到的最大元素（即组大小满足当前阈值的最大元素）

棘手的一步是计算组的大小。我们保留一个堆栈并从头到尾扫描数组。对于每个元素，我们弹出大于它的堆栈元素，从而结束它们的组。下面是

6 1 3 2 5 4 7

上的跟踪

stack: (-inf @ -1)  {sentinel}

6 1 3 2 5 4 7 -inf  {sentinel}
^
stack: (-inf @ -1), (6 @ 0)

6 1 3 2 5 4 7 -inf
  ^
pop (6 @ 0): group size of 6 is (1 - (-1)) - 1 = 1
stack: (-inf @ -1), (1 @ 1)

6 1 3 2 5 4 7 -inf
    ^
stack: (-inf @ -1), (1 @ 1), (3 @ 2)

6 1 3 2 5 4 7 -inf
      ^
pop (3 @ 2): group size of 3 is (3 - 1) - 1 = 1
stack: (-inf @ -1), (1 @ 1), (2 @ 3)

6 1 3 2 5 4 7 -inf
        ^
stack: (-inf @ -1), (1 @ 1), (2 @ 3), (5 @ 4)

6 1 3 2 5 4 7 -inf
          ^
pop (5 @ 4): group size of 5 is (5 - 3) - 1 = 1
stack: (-inf @ -1), (1 @ 1), (2 @ 3), (4 @ 5)

6 1 3 2 5 4 7 -inf
            ^
stack: (-inf @ -1), (1 @ 1), (2 @ 3), (4 @ 5), (7 @ 6)

6 1 3 2 5 4 7 -inf
              ^
pop (7 @ 6): group size of 7 is (7 - 5) - 1 = 1
pop (4 @ 5): group size of 4 is (7 - 3) - 1 = 3
pop (2 @ 3): group size of 2 is (7 - 1) - 1 = 5
pop (1 @ 1): group size of 1 is (7 - (-1)) - 1 = 7
stack: (-inf @ -1), (inf @ 7)

---

我读了你的描述好几次，仍然无法找出你想要指定的内容。你能在你的示例答案中提供更多关于你如何得出“3,2,1”的细节吗？@SpecialSause size=1可能的连续子数组-{1}，{2}，{3}，现在最小值的最大值将是3，size=2，可能的连续子数组{1,2}{2,3}.现在最小值的最大值将是2，同样，对于size=3，最小值的最大值将是1，所以答案是3,2,1我对这个问题的理解是输入

[1,2,2,1,2]

应该给出输出

[2,2,1,1]。这是不对的？如果答案是正确的，那么你的答案是错误的。考虑n＝7的情况，数字是-1，2，3，4，5，4，6的反向排序将使它变成6，5，4，4，3，2，所以根据你，当X＝2回答是5，但是在这种情况下答案是4。请在回答任何问题之前检查你的答案。首先，我从不放弃。n对任何问题都投了票。即使你的解释不够充分，我也试图回答。@user3703826在你给出的示例中，答案仍然是5。长度为2的子数组将是{5，6}，给出的最小元素是5。@harsh，段应该是连续的。它是否适用于
[6,1,3,2,5,4,7]>[7,4,4,2,1,1]
@ooga，是的。每次迭代（通过应用shinking操作找到）的a值是[6,1,3,2,5,4,7]，[1,1,2,2,4,4]，[1,1,2,2,4]，[1,1,2,2]，[1,1,2]，[1,1]，[1,1]，[1]，这些数组的最大值是[7,4,4,2,2,1,1]
#include <stdio.h>

int main() {
    int a[] = {6,1,3,2,5,4,7};
    size_t i, N = sizeof a / sizeof *a;

    for (i=0; i<N; ++i) printf("%d ", a[i]); puts("\n");

    while(N > 0)
    {
        int max = a[0];
        for(i = 0; i < N - 1; i++)
        {
            if(a[i+1] > max)
               max = a[i+1];
            a[i] = a[i+1] < a[i] ? a[i+1] : a[i];
        }
        printf("%d ", max);
        N--;
    }

    return 0;
}

stack: (-inf @ -1)  {sentinel}

6 1 3 2 5 4 7 -inf  {sentinel}
^
stack: (-inf @ -1), (6 @ 0)

6 1 3 2 5 4 7 -inf
  ^
pop (6 @ 0): group size of 6 is (1 - (-1)) - 1 = 1
stack: (-inf @ -1), (1 @ 1)

6 1 3 2 5 4 7 -inf
    ^
stack: (-inf @ -1), (1 @ 1), (3 @ 2)

6 1 3 2 5 4 7 -inf
      ^
pop (3 @ 2): group size of 3 is (3 - 1) - 1 = 1
stack: (-inf @ -1), (1 @ 1), (2 @ 3)

6 1 3 2 5 4 7 -inf
        ^
stack: (-inf @ -1), (1 @ 1), (2 @ 3), (5 @ 4)

6 1 3 2 5 4 7 -inf
          ^
pop (5 @ 4): group size of 5 is (5 - 3) - 1 = 1
stack: (-inf @ -1), (1 @ 1), (2 @ 3), (4 @ 5)

6 1 3 2 5 4 7 -inf
            ^
stack: (-inf @ -1), (1 @ 1), (2 @ 3), (4 @ 5), (7 @ 6)

6 1 3 2 5 4 7 -inf
              ^
pop (7 @ 6): group size of 7 is (7 - 5) - 1 = 1
pop (4 @ 5): group size of 4 is (7 - 3) - 1 = 3
pop (2 @ 3): group size of 2 is (7 - 1) - 1 = 5
pop (1 @ 1): group size of 1 is (7 - (-1)) - 1 = 7
stack: (-inf @ -1), (inf @ 7)