Question

给定一系列无序的n个整数，S = a1，a2，a3 ......

以n为单位给出最长非递减子序列长度的形式和递归定义。

所以，我的想法是，如果我们递归地定义它，那么序列中的每个整数都是一个长度为1的序列，并且包含一个长度为1的非递减子序列。这是说出这个的正确方法还是我完全离开？

Answer 1

我已经想到了这个解决方案。我用伪代码写了它。

define function non_decreasing_subsequence (index, sub_sequence, initial_sequence )
{
    sub_sequence.add(index)

    if initial_sequence[index+1] is not defined
        return lenght of sub_sequence

    if initial_sequence[index] <= initial_sequence[index+1]
        call non_decreasing_subsequence (index+1, sub_sequence, initial_sequence)
    else 
        return lenght of sub_sequence
}

for i between 1 and lenght of initial_sequence
    call non_decreasing_subsequence (i, empty_sequence, initial_sequence)

你将以这种方式计算跟随整数的每个非递减子序列的长度。现在你可以获得这些长度的最大值！

Answer 2

除了你所处的元素之外，在递归中有两个变量可能更好。一个具有历史最大值，一个具有当前长度的上升元素。如果数组有元素，则保证1并计数直到下一个元素降序，然后重新启动，可能是新的历史最大值，或者列表最后返回当前长度和历史最大值的最大值。

像这样的Scheme实现？

(define (longest-increasing-sequence lst)
  (if (null? lst)
      0
      (let recur ((lst lst) (cur 1) (hmax 0))
        (cond ((null? (cdr lst)) (max hmax cur))
              ((<= (car lst) (cadr lst)) (recur (cdr lst) (+ cur 1) hmax))
              (else (recur (cdr lst) 1 (max hmax cur)))))))

这是使用数组而不是链接列表的PHP版本：

function longest_increasing_sequence($lst)
{
    $stop = count($lst)-1;
    if( $stop < 0 )
        return 0;

    // makes an anonymous function closed over &$lst, $stop and &$recur
    $recur = function( $idx, $cur_len, $max_len ) use (&$lst, $stop, &$recur)
             {
                 $new_idx=$idx+1;

                 if( $idx == $stop )
                     return max($cur_len, $max_len);
                 elseif( $lst[$idx] <= $lst[$new_idx] )
                     return $recur($new_idx, $cur_len + 1, $max_len);
                 else
                     return $recur($new_idx, 1, max($cur_len, $max_len));
             };

    // start recursion
    return $recur(0, 1, 0);
}

Answer 3

纯粹递归：

-module(lndss).

-export([get_len/1]).

get_len([]) -> 0;
get_len([H|T]) -> get_len(H, T, 1, 1).

get_len(_, [], C, M) -> max(C, M);
get_len(P, [H|T], C, M) when H < P -> get_len(H, T, 1, max(C, M));
get_len(_, [H|T], C, M) -> get_len(H, T, C+1, M).

需要帮助给出递归定义

3 个答案: