Question

例如，我有： List(1,3,2,5)

我如何获得所有这些： List(1), List(3), List(2), List(5), List(1,3), List(1,2), List(1,5), List(3,2), List(3,5), List(2,5), List(1,3,2), List(1,3,5), List(1,2,5), List(3,2,5), List(1,3,2,5))

对于最长增长子序列-问题，我需要这个，例如，答案是：（1,3,5）

我想将其用于更大的列表。

Answer 1

您希望所有smallest = np.inf index = None for i in range(len(b)): if b[i] > 0: if(a[i] < smallest): smallest = a[i] index = i从1到数组的长度。

combinations()

更新

这将为您提供所有可能的组合，并保留原始顺序和重复元素。

val arr = Array(4, 3, 1)

arr.indices.flatMap(x => arr.combinations(x + 1))
//res0: Seq[Array[Int]] = Vector(Array(4), Array(3), Array(1), Array(4, 3), Array(4, 1), Array(3, 1), Array(4, 3, 1))

结果是def subseqs[A](seq :Seq[A]) :List[Seq[A]] = seq match { case hd +: tl => val res = subseqs(tl) Seq(hd) :: res ++ res.map(hd +: _) case Seq() => Nil }的n ^ 2-1个可能的子序列。因此，对于8个元素的集合，您将获得255个子序列。

对于您的目的，这当然会很繁琐且效率低下。生成所有可能的子序列以找到最长的增长，就像在附近洗所有衣服一样，这样一来早晨便会干净袜子。

最好只生成递增的子序列，并从该集合中找到最长的子序列（9行代码）。

Answer 2

[更新以响应更新的问题]

[感谢@jwvh在原始版本中发现错误]

此方法将生成List的所有可能的子序列：

def subsequences[T](list: List[T]): List[List[T]] =
  list match {
    case Nil =>
      List(List())
    case hd :: tl =>
      val subs = subsequences(tl)

      subs.map(hd +: _) ++ subs
  }

请注意，由于多种原因，这种方法效率不高，因此，它不是解决“最长增长子序列问题”的好方法。

[原始答案]

此函数将生成任何序列的所有非空连续子序列：

 def subsequences[T](seq: Seq[T]) =
   seq.tails.flatMap(_.inits).filter(_.nonEmpty)

这将返回一个Iterator，因此依次创建每个子序列，从而减少了内存使用。

请注意，与使用combinations或Set的解决方案不同，这将生成所有子序列并保留值的顺序。

您可以像这样在“最长增长子序列问题”中使用它：

def isAscending(seq: Seq[Int]): Boolean =
  seq.length <= 1 || seq.sliding(2).forall(x => x(0) < x(1))

subsequences(a).filter(isAscending).maxBy(_.length)

结果将是输入a中最长的升序序列。

Scala中的数字序列中的子序列

2 个答案: