Python program for Longest Increasing Subsequence

# A naive Python implementation of LIS problem


# Global variable to store the maximum
global maximum


# To make use of recursive calls, this function must return
# two things:
# 1) Length of LIS ending with element arr[n-1]. We use
# max_ending_here for this purpose
# 2) Overall maximum as the LIS may end with an element
# before arr[n-1] max_ref is used this purpose.
# The value of LIS of full array of size n is stored in
# *max_ref which is our final result
def _lis(arr, n):

    # To allow the access of global variable
    global maximum

    # Base Case
    if n == 1:
        return 1

    # maxEndingHere is the length of LIS ending with arr[n-1]
    maxEndingHere = 1

    # Recursively get all LIS ending with
    # arr[0], arr[1]..arr[n-2]
    # If arr[i-1] is smaller than arr[n-1], and
    # max ending with arr[n-1] needs to be updated,
    # then update it
    for i in range(1, n):
        res = _lis(arr, i)
        if arr[i-1] < arr[n-1] and res+1 > maxEndingHere:
            maxEndingHere = res + 1

    # Compare maxEndingHere with overall maximum. And
    # update the overall maximum if needed
    maximum = max(maximum, maxEndingHere)

    return maxEndingHere


def lis(arr):

    # To allow the access of global variable
    global maximum

    # Length of arr
    n = len(arr)

    # Maximum variable holds the result
    maximum = 1

    # The function _lis() stores its result in maximum
    _lis(arr, n)
    return maximum


# Driver program to test the above function
if __name__ == '__main__':
    arr = [10, 22, 9, 33, 21, 50, 41, 60]
    n = len(arr)

    # Function call
    print("Length of lis is", lis(arr))

# This code is contributed by NIKHIL KUMAR SINGH

# A Naive Python recursive implementation
# of LIS problem


import sys

# To make use of recursive calls, this
# function must return two things:
# 1) Length of LIS ending with element arr[n-1].
#     We use max_ending_here for this purpose
# 2) Overall maximum as the LIS may end with
#     an element before arr[n-1] max_ref is
#     used this purpose.
# The value of LIS of full array of size n
# is stored in *max_ref which is our final result


def f(idx, prev_idx, n, a, dp):

    if (idx == n):
        return 0

    if (dp[idx][prev_idx + 1] != -1):
        return dp[idx][prev_idx + 1]

    notTake = 0 + f(idx + 1, prev_idx, n, a, dp)
    take = -sys.maxsize - 1
    if (prev_idx == -1 or a[idx] > a[prev_idx]):
        take = 1 + f(idx + 1, idx, n, a, dp)

    dp[idx][prev_idx + 1] = max(take, notTake)
    return dp[idx][prev_idx + 1]

# Function to find length of longest increasing
# subsequence.


def longestSubsequence(n, a):

    dp = [[-1 for i in range(n + 1)]for j in range(n + 1)]
    return f(0, -1, n, a, dp)


# Driver program to test above function
if __name__ == '__main__':
    a = [3, 10, 2, 1, 20]
    n = len(a)

    # Function call
    print("Length of lis is", longestSubsequence(n, a))

# This code is contributed by shinjanpatra

# Dynamic programming Python implementation
# of LIS problem


# lis returns length of the longest
# increasing subsequence in arr of size n
def lis(arr):
    n = len(arr)

    # Declare the list (array) for LIS and
    # initialize LIS values for all indexes
    lis = [1]*n

    # Compute optimized LIS values in bottom up manner
    for i in range(1, n):
        for j in range(0, i):
            if arr[i] > arr[j] and lis[i] < lis[j] + 1:
                lis[i] = lis[j]+1

    # Initialize maximum to 0 to get
    # the maximum of all LIS
    maximum = 0

    # Pick maximum of all LIS values
    for i in range(n):
        maximum = max(maximum, lis[i])

    return maximum


# Driver program to test above function
if __name__ == '__main__':
    arr = [10, 22, 9, 33, 21, 50, 41, 60]
    print("Length of lis is", lis(arr))


# This code is contributed by Nikhil Kumar Singh