数组的最长递增数子序列答案

【问题标题】：Longest Increasing Numeral sub-sequence of array数组的最长递增数子序列
【发布时间】：2018-05-19 05:39:36
【问题描述】：

我们在课程中遇到了这个问题，我与之交谈过的人都没有解决它。我想要一些帮助。那么问题来了：

令 A 为长度为 n 的数组，其中包含 n 位数字（数字在 0-9 之间）。 A的数字子序列是正数的序列，当序列中某个数字的所有数字在A中出现一行时，它们的数字组成A的子序列。 p>

例如：序列13,1,345,89,23是输入数组A的数字子序列： [1,3,5,1,2,3,4, 5,8,9,4,5,2,3]

数字子序列的长度是出现在其中的数字的数量（在上面的示例中：5）如果序列中的每个数字都大于它之前的数字，则数字子序列递增。

请求是在动态规划方法（基于递归公式）中找到一种算法，该算法找到输入数组 A 的最长递增数字子序列。

提前感谢所有帮助者！

【问题讨论】：

我认为这类似于 最长递增子序列 问题，但有一个附加限制，即仅选择所有数字都存在于数组 A 中的那些数字。因此，首先，您删除序列13,1,345,89,23, 400 中的所有数字，其中至少一个数字不存在于数组A 中。在这种情况下，我们将删除400。（现在任何序列都将形成一个数字子序列）。其次，您只需对剩余数字（13,1,345,89,23）按照通常的最长递增子序列方法来找到最长递增数字子序列。
我认为不够清楚：我根本没有任何序列。我得到的只是数组——我需要找到的是输入数组的最大长度的数字递增子序列。我同意这个想法类似于 LIS 问题，但我仍然看不到如何使用它。
哦！你没有这么说。所以，我只是假设也提供了序列。
因此，最终序列中的所有数字都应具有数组A中的数字。我对吗？你需要找到最长序列的长度还是序列本身？如果我说91 是A 的数字，它是否有效？另外，这 (31, 1, 543, 98, 32) 是 A 的有效数字子序列吗？
我需要找到序列本身。可能有不止一种选择，但重要的是它会以最大长度。 91 不是数字子序列，因为 A 中没有 9 和 1。 (31, 1, 543, 98, 32) 是 A 的有效数字子序列 - 但不会增加......

标签： algorithm recursion dynamic-programming

【解决方案1】：

查看数组中的第一个数字。该数字不是您的数字序列中的数字的一部分，或者它是。如果是，则该数字可能有 1、2、...、n 位。对于每个猜测，返回：

不在数字中：返回f(array[2...n], -1)
一位数的第一位：返回array[1] union f(array[2...n], number(array[1]))
两位数的第一位：返回array[1...2] union f(array[3...n], number(array[1...2]))
三位数字的第一位：返回array[1...3] union f(array[4...n], number(array[1...3]))
...
n位数的第1位：返回array[1...n]

您可以在此处进行一些优化以跳过一些步骤。

f(array[1...k], x) = f(array[1...k], y) 如果给定假设的最后一个数字x 和y 的序列中下一个数字的最小选择相同。所以，如果array[1...k] 中下一个数字的最小选择对于x 和y 是相同的，并且我们已经计算了x 的f 的值，我们可以为y 重用该值.
f(array[1...k], x) = c + f(array[2...k], x) 每当array[1] = 0，其中c = 1 如果x < 0 和c = 0 如果x >= 0。也就是说，我们可以忽略前导零，除了可能在数组开头的前导零，它应该始终被选为我们的第一个一位数字。
在决定一个数字是否是k-digit 数字的第一个数字时，如果您从不选择前导零，则您知道序列中剩余数字数量的上限由 @ 给出987654342@，因为在此之后选择的任何数字都需要至少为 k 数字长。如果您还记得目前为止看到的最长序列，您可以识别出没有希望做得比您看到的更好的路径并忽略它们。
如果一个数组中至少有k(k+1)/2非零数字，则通过取1、2、...、k非零的数字得到一个长度至少为k的数列零位从左到右依次排列。因此，如果您预先计算此值，您可能会立即避开一些路径。

这里是粗略的伪代码以及讨论的优化：

solve(array[1...n])

    z = number of non-zero entries in array
    last_number = -1
    min_soln = floor((sqrt(1 + 8z) - 1) / 2)
    return solve_internal(array[1...n], min_soln, last_number)



memo = {}

solve_internal(array[1...n], min_soln, last_number)

    // ignore potentially leading zeroes except the first one
    if array[1] = 0 then
        if last_number < 0 then
            return {0} union solve_internal(array[2...n], min_soln - 1, 0)
        else then
            return solve_internal(array[2...n], min_soln, last_number)

    // abort since we don't have enough digits left to get a solution
    if floor(n / #digits(last_number)) < min_soln return []

    // look up current situation in previous partial solutions
    z = smallest number formable in array greater than last_number
    if memo contains (n, z) then
        return memo[n, z]

    soln = {}
    for k = 1 to n do
        soln_k = solve_internal(array[k+1...n], min_soln - 1, array[1...k])
        if |soln_k| > |soln| then
            soln = soln_k
            min_soln = |soln|

    memo[n, z] = soln
    return soln

【讨论】：

嗨，您能否澄清一些事情以确保我做对了： 1. min_soln 和 memo 究竟代表什么？ 2. 为什么一开始我们用这种方式计算 min_soln ： floor((sqrt(1 + 8z) - 1) / 2) ？
@OriNetanelBen-Zaken min_soln 是必须返回可行的最小长度数序列；如果我们发现我们无法做到这一点，我们就会中止。 memo 是已经计算的部分解决方案的记录，因此我们可以重用我们已经关闭的分支。 min_soln 的初始计算来自以下观察：任何具有 k(k+1)/2 个非零数字的数组都有一个长度至少为 k 的数字序列，通过取 1 位、2 位、...、k 位来实现转动。也许 min_soln 应该设置为比这小一以解决最坏的情况。
好的。绝对更清晰，实际上更精彩。我只问一件事？如果我在递归函数的每次运行中都做对了（在停止条件下没有停止），我们计算 z （这可能需要 O(n) 时间）。如果是这样，那么为什么在 for 循环中我们忽略它并每次都以 array[1...k] 作为最后一个数字递归调用？我现在有点困惑。一切都很好，直到我们开始 for 循环。你能解释一下吗？
@OriNetanelBen-Zaken for 循环根据我们讨论的优化之一处理我们不过早中止或返回的情况。事实上，算法的其余部分可以被删除，这本身就可以保证正确的结果。它假设当前数字是一个新的 k 位数字的第一个数字，并在每个假设下计算出结果最大序列的长度，记住给出最佳结果的假设。注意：看起来我忽略了“猜测”该数字不是任何数字的一部分；这是我的代码中要纠正的错误。
（要修复上述错误，请将soln = {} 替换为soln = solve_internal(array[2...n], min_soln, last_number)，因为这是不使用数组中第一位数字的最长数字序列）。