Find the largest sorted subset [duplicate] - algorithm

Question

This question already has an answer here:
finding largest increasing subset of an array (non-contiguous)
(1 answer)
Closed 4 years ago.
I need to create an algorithm that extracts one of the largest possible subsets from a list, in which all elements are ordered. This subset can be non-consecutive, but must preserve the order from the original list. For example:
Input: Possible Output:
[1,2,8,3,6,4,7,9,5] -> [1,2,3,6,7,9]
One might rephrase the question as "which elements do I at least have to remove so that the remaining list is sorted".
I'm not looking for an implementation, but just for ideas for a simple algorithm.
My best approach so far would be to build a tree with nodes for each number, and their children being all larger numbers following in the list. Then the longest path down the tree should equal the sorted subset. However, that seems overly complicated.
Context: this is to check student's answers on a test where they have to order items by size. I want to find out for how many they got right, relative to each other.

Answer 1

A recursive implementation in Scala with standard list functions (size, map, filter, dropWhile, reduce):
def longestClimb (nx: List[Int]) : List[Int] = nx match {
case Nil => Nil
case _ => {
val lix = nx.map (n => n :: longestClimb (nx.dropWhile (_ != n).filter (_ > n)))
lix.reduce ((a, b) => if (a.size > b.size) a else b)
}
}
Invocation:
scala> val nx = List (1, 2, 8, 3, 6, 4, 7, 9, 5)
scala> longestClimb (nx)
res7: List[Int] = List(1, 2, 3, 4, 7, 9)
Prosa: For an empty list, the result is the empty list and the end of the recursive process.
For the whole list, every point is tried as starting point. Let's look for example at the 6 value. For the 6 is evaluated longestClimb of nx.dropWhile (_ != 6) (which is 6, 4, 7, 9, 5) filtered for (_ > 6) which reduces the former sample to (7, 9) which results in the List (6, 7, 9).
That's hardly the longest List over all, but a candidate for a longest sublist, but since only one largest List is searched, the bias of lix.reduce ((a, b) => if (a.size > b.size) a else b) yields another list of equal length, while lix.reduce ((a, b) => if (a.size >= b.size) a else b) would have resulted in the equal length list (1, 2, 3, 6, 7, 9).
To measure, how far we get with this approach, I use a timing and an iterating function:
def timed (name: String) (f: => Any) = {
val a = System.currentTimeMillis
val res = f
val z = System.currentTimeMillis
val delta = z-a
println (name + ": " + (delta / 1000.0))
res
}
val r = util.Random
def testRandomIncreasing (max: Int) : Unit = {
(2 to max).map { i =>
val cnt = Math.pow (2, i).toInt
val l = (1 to cnt).toList
val lr = r.shuffle (l)
val s = f"2^${i}=${cnt}\t${lr}%s"
val res = timed (s) (longestClimb (lr))
println (res)
}
}
and the results are pretty interesting:
testRandomIncreasing (7)
2^2=4 List(2, 4, 3, 1): 0.0
List(2, 3)
2^3=8 List(2, 7, 5, 6, 8, 1, 4, 3): 0.0
List(2, 5, 6, 8)
2^4=16 List(15, 6, 10, 7, 1, 16, 9, 4, 13, 14, 5, 2, 8, 11, 3, 12): 0.0
List(1, 4, 5, 8, 11, 12)
2^5=32 List(1, 5, 30, 26, 27, 7, 20, 6, 29, 23, 31, 21, 22, ...10): 0.002
List(1, 5, 6, 13, 14, 15, 16, 18)
2^6=64 List(2, 57, 7, 45, 51, 49, 4, 16, 23, 21, 5, 3, 62, ... 55): 0.899
List(2, 4, 5, 9, 12, 14, 18, 19, 26, 31, 36, 41, 42, 54, 55)
2^7=128 List(16, 106, 65, 94, 84, 13, 57, 52, 117, 48, 38, ... 110): 42.195
List(13, 14, 33, 35, 37, 40, 53, 55, 58, 74, 75, 78, 97, 114, 116, 121, 123, 128)
Interesting, in that the last step from 64 to 128 values, the time increased by a factor of about 40. A former test with another random seed, lead to a factor of about 2000 and it took about 8 minutes for 2^7 values in the REPL. The test for 2^8 elements had to be interrupted, because I didn't want to wait 11 days for the result in the worst case.