Sorting 查找具有最佳复杂性的数组中唯一连续递增子序列的数目

假设给定一个数组[1，2，3，…，n]。现在随机洗牌。在时间和空间复杂度方面，找到洗牌数组中唯一连续增加的子序列数的最佳方法是什么

例如，a=[1,2,3,6,5,4,7,8,9]有3个子序列： [1,2,3,4]，[6,7,8,9]，[5]。（[5]基本满足定义）

提前谢谢

编辑：我想的一种方法是，每当我们遇到一个新元素时，检查它是否是前一个元素的+1，如果不将它放入一个新数组中。但是当有许多这样的数组时，检查下一个元素是否是任何现有数组中最后一个元素的+1需要更长的时间。因此，空间复杂度为n，但在最坏的情况a=[n，n-1，n-2，…，1]是1+2+3+…+n-1=O（n^2）。但可能有更好的方法

编辑2：抱歉，我刚刚意识到，能够输出这些子序列的显式形式也很重要（如给出的示例所示）。因此，有两种最复杂的情况，一种用于计算数字，另一种用于输出显式形式。

我提出了这一点（在Java中）：

public int countsubsequence（int[]数组）{
int numberofsubsequence=0；
for（int i=0；i数组[i+1]）{
numberofsubsequence++；
}
}
numberofsubsequence++；
返回子序列的数目；
}

我只是迭代数组，检查数组中的下一个元素是否小于当前元素。如果是这种情况，则当前元素是子序列的结尾，我们可以增加计数。在返回之前，我们也需要增加，因为数组的结尾也是最后一个子序列的结尾

---

时间复杂度是线性的，所以

O=（n）

和空间复杂度应该是常数

O=（1）

因为我们不需要用这种方法记住子序列来计算它们。

您可以通过计算条纹开始数来计算条纹。如果您以前没有看到

x-1

，则值

x

是条纹开始。在您的示例中，这是1、6和5。需要O（n）时间和空间

a = [1,2,3,6,5,4,7,8,9]

streaks = 0
seen = set()
for x in a:
    if x - 1 not in seen:
        streaks += 1
    seen.add(x)

print(streaks)

输出：

---

如果允许修改

a

（例如，记住

x

，如通过对

a[x-1]

求反所见），则可以是O（1）空格

输出：

---

收集条纹的版本，O（n）时间和空间：

a = [1,2,3,6,5,4,7,8,9]

streaks = {}
for x in a:
    streak = streaks.pop(x - 1, [])
    streak.append(x)
    streaks[x] = streak

print(*streaks.values())

输出：

---

'检查数组中的下一个元素是否小于我的当前元素。如果是这种情况，则下一个元素是子序列的结尾。在我的示例中，第一个这样的情况是5，但6已经是另一个这样的子序列的开始。很抱歉，我没有真正遵循。第一个子序列的结尾满足要求是实际的ly 4.我在解释时出错。我的意思是，如果是这种情况，则当前元素是子序列的结尾。您确定[1,2,3,6,5,4,7,8,9]的子序列应该是[1,2,3,4]，[6,7,8,9]，[5]，而不是[1,2,3,6][4,7,8,9]？例如，

[1,6,2,7,3,8,4,9]

返回

5

。正确答案是

（因为子序列是
[1,2,3,4,5]
和
[6,7,8,9]
）。这个问题是否在线，以便我们可以尝试在那里提交解决方案？
3

a = [1,2,3,6,5,4,7,8,9]

streaks = 0
for x in map(abs, a):
    if a[x-2] > 0:
        streaks += 1
    a[x-1] *= -1

print(streaks)

3

a = [1,2,3,6,5,4,7,8,9]

streaks = {}
for x in a:
    streak = streaks.pop(x - 1, [])
    streak.append(x)
    streaks[x] = streak

print(*streaks.values())

[5] [1, 2, 3, 4] [6, 7, 8, 9]