def fibonacci(n):
    if n == 1 or n === 2:
        return 1
    else:
        return fibonacci(n-1) + fibonacci(n-2)

def fibonacci(n):
    if n == 1 or n === 2:
        return 1
    else:
        return fibonacci(n-1) + fibonacci(n-2)

fibonacci_memo={}
def fibonacci(n):
    if(n in fibonacci_memo):
        return fibonacci_memo[n]
    elif n==1 or n==0:
        val = 1
    else:
        val = fibonacci(n-1) + fibonacci(n-2)
    fibonacci_memo[n] = val
    return val

fibonacci_memo = {}
def fibonacci(n):
    for k in range(0,n):
        if k < 2:
            f = 1
        else:
            f = fibonacci_memo[k-1] 
            + fibonacci_memo[k-2]
        fibonacci_memo[k] = f
    return fibonacci_memo[n]

# No python
def CUT-ROD(p,n):
  if n == 0
  	return 0
  q = -infinity
  for i in 1 .. n
  	q = max(q, p(i) + Cut-Rod(p, n-i))
  return q

# No python
def TOP-DOWN-CUT-ROD(p,n):
  r = []
  for i in 1 .. n
  	r[i] = -infinity
  return TOP-DOWN-CUT-ROD-AUX(p,n,r)

def TOP-DOWN-CUT-ROD-AUX(p,n,r):
  if r[n] >= 0
    return r[n]
  if n == 0
    q = 0
  else
    q = -infinity
    for i in 1 .. n
      q = max(q,p[i] + TOP-DOWN-CUT-ROD-AUX(p,n-i,r))
  r[n] = q
return q

# No python
def BOTTON-UP-CUT-ROD(p,n):
  r = [0] * n
  for j in 1 .. n
    q = -infinity
    for i in 1 .. j
      q = max(q,p[i] + r[j-i])
    r[j] = q
  return r[n]

#longest increasing subsequence
def lis(array):
    l = len(array)
    # Inside LIS we want to record the subproblem LIS[i]
    # i.e LIS[i] contains the longest increasing subsequence
    # that ends at i. LIS is initialized with all records in 1
    # because an unary array has lis 1
    LIS = [1] * l
    for i in range(1,l):
        subproblems = []
        # The idea is to test each increasing subsequence ending at i
        for k in range(i):
            # if the k element keeps the subsequence increasing
            # the recorded LIS at k should be store
            if array[k] < array[i]:
                subproblems.append(LIS[k])
        # The LIS at i should be the max of the LIS for the subproblems
        # plus one because i is a new element of the sequence.
        # Notice tha if subproblems is empty LIS[i] don't change. 
        # subproblems empty means that there is no lower element that
        # array[i] for all j<i
        # In this case default means that max([],default=0) = 0
        LIS[i] = 1 + max(subproblems,default=0)
    #return the max longest increasing subsequence
    return max(LIS,default=0)

def lis(array):
    l = len(array)
    LIS = [1] * l
    max_LIS = 0
    for i in range(1,l):
        max_lis_sub = 0
        for k in range(i):
            if array[k] < array[i]:
                max_lis_sub =  max(max_lis_sub,LIS[k])
        max_LIS = max(1 + max_lis_sub, max_LIS)
        LIS[i] = 1 + max_lis_sub 
    return max_LIS 

def lis(array):
    l = len(array)
    LIS = [1] * l
    max_LIS = 0
    for i in range(1,l):
        for j in range(i):
            if array[j] < array[i]:
                if 1 + LIS[j] > LIS[i]:
                    LIS[i] = 1 + LIS[j]