最长递增子序列-dp问题

Longest Increasing Subsequence

The longest increasing subsequence problem is to find a subsequence of a given sequence in which the subsequence's elements are in sorted order, lowest to highest, and in which the subsequence is as long as possible. This subsequence is not necessarily contiguous, or unique.

Example

In the first 16 terms of the binary Van der Corput sequence

0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15

a longest increasing subsequence is

0, 2, 6, 9, 11, 15.

This subsequence has length six; the input sequence has no seven-member increasing subsequences. The longest increasing subsequence in this example is not unique: for instance,

0, 4, 6, 9, 11, 15 or
0, 2, 6, 9, 13, 15 or
0, 4, 6, 9, 13, 15

are other increasing subsequences of equal length in the same input sequence.

output：6

思路：

1.初始化一个长度数组lengthsArray,值全为1

2.声明两个变量previousIndex=0,currentIndex=1;

3通过currentIndex<sequence.length遍历sequence

　　（1）若sequence[previousIndex]<sequence[currentIndex],则lengthsArray[currentIndex]=max(lengthsArray[currentIndex],lengthsArray[previous]+1)

　　（2）previousIndex++;

　　（3）若previousIndex=currentIndex,则previous=0,currentIndex++;

代码如下：

/**
 * Dynamic programming approach to find longest increasing subsequence.
 * Complexity: O(n * n)
 *
 * @param {number[]} sequence
 * @return {number}
 */
export default function dpLongestIncreasingSubsequence(sequence) {
  // Create array with longest increasing substrings length and
  // fill it with 1-s that would mean that each element of the sequence
  // is itself a minimum increasing subsequence.
  const lengthsArray = Array(sequence.length).fill();

  let previousElementIndex = ;
  let currentElementIndex = ;

  while (currentElementIndex < sequence.length) {
    if (sequence[previousElementIndex] < sequence[currentElementIndex]) {
      // If current element is bigger then the previous one then
      // current element is a part of increasing subsequence which
      // length is by one bigger then the length of increasing subsequence
      // for previous element.
        lengthsArray[currentElementIndex] = max(lengthsArray[currentElementIndex],lengthsArray[previousElementIndex] + );
      }

    // Move previous element index right.
    previousElementIndex += ;

    // If previous element index equals to current element index then
    // shift current element right and reset previous element index to zero.
    if (previousElementIndex === currentElementIndex) {
      currentElementIndex += ;
      previousElementIndex = ;
    }
  }

  // Find the biggest element in lengthsArray.
  // This number is the biggest length of increasing subsequence.
  let longestIncreasingLength = ;

  for (let i = ; i < lengthsArray.length; i += ) {
    if (lengthsArray[i] > longestIncreasingLength) {
      longestIncreasingLength = lengthsArray[i];
    }
  }

  return longestIncreasingLength;
}