Longest Increasing Subsequence in DSA Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the Longest Increasing Subsequence (LIS) in a sequence of numbers?

The Longest Increasing Subsequence is the longest sequence of numbers from the original sequence where each number is strictly greater than the previous one, but the numbers do not need to be consecutive in the original sequence.

intermediate

What is the time complexity of the classic dynamic programming approach to find LIS?

The classic dynamic programming approach to find LIS has a time complexity of O(n²), where n is the length of the input sequence.

advanced

In LIS problem, why do we use binary search in the optimized approach?

Binary search is used to efficiently find the position to replace or insert elements in a temporary array that keeps track of the smallest possible tail values for increasing subsequences of different lengths, reducing time complexity to O(n log n).

intermediate

What does the temporary array represent in the O(n log n) LIS algorithm?

The temporary array stores the smallest possible last elements (tails) of increasing subsequences of various lengths found so far, helping to build longer increasing subsequences efficiently.

advanced

How can you reconstruct the actual Longest Increasing Subsequence after computing its length?

You can keep track of predecessors (indexes of previous elements) during the LIS computation and then backtrack from the last element of the LIS to reconstruct the full sequence.

What is the minimum length of the Longest Increasing Subsequence in any non-empty sequence?

A Length of the sequence

B 0

C 1

D 2

At least one element itself forms an increasing subsequence of length 1.

Which approach has better time complexity for LIS: classic dynamic programming or binary search optimization?

A Classic dynamic programming (O(n²))

B Neither can solve LIS

C Both have same time complexity

D Binary search optimization (O(n log n))

Binary search optimization reduces the time complexity to O(n log n), which is faster than O(n²).

In the optimized LIS algorithm, what does replacing an element in the temporary array represent?

A Improving a subsequence to have a smaller tail

B Starting a new subsequence

C Removing an element from the sequence

D Extending the longest subsequence

Replacing an element means we found a smaller tail for a subsequence of that length, which may help build longer subsequences later.

Which data structure is commonly used to implement the binary search in the optimized LIS algorithm?

A Array

B Queue

C Stack

D Linked List

An array is used to store the tails, and binary search is performed on this array.

Can the LIS contain elements that are not adjacent in the original sequence?

A No

B Yes

C Only if they are consecutive

D Only if they are equal

LIS is a subsequence, so elements can be non-adjacent but must maintain order.

Explain the difference between the classic dynamic programming and the optimized binary search approach for finding the Longest Increasing Subsequence.

Think about how the temporary array helps reduce comparisons.

Describe how you would reconstruct the actual Longest Increasing Subsequence after computing its length using dynamic programming.

Keep extra information during computation to help build the sequence later.

Practice

1. What does the Longest Increasing Subsequence (LIS) problem ask for in a given sequence of numbers?

easy

A. The longest subsequence where each number is smaller than the previous one

B. The longest contiguous subarray with equal elements

C. The longest subsequence where each number is larger than the previous one

D. The sum of all increasing numbers in the sequence

Solution

1. Step 1: Understand the LIS definition

   The LIS is a subsequence (not necessarily contiguous) where every next number is strictly greater than the previous.

2. Step 2: Compare options with definition

   The longest subsequence where each number is larger than the previous one matches the LIS definition exactly. Other options describe different concepts.

3. Final Answer:

   The longest subsequence where each number is larger than the previous one -> Option C

4. Quick Check:

   LIS = strictly increasing subsequence [OK]

Hint: LIS means strictly increasing numbers in order [OK]

Common Mistakes:

• Confusing subsequence with subarray
• Thinking LIS requires contiguous elements
• Mixing increasing with decreasing sequences

2. Which of the following Go code snippets correctly initializes a slice to store LIS lengths for each element in an input array nums?

easy

A. lis := make([]int, 0, len(nums))

B. lis := []int{}

C. var lis [len(nums)]int

D. lis := make([]int, len(nums))

Solution

1. Step 1: Understand slice initialization for fixed length

   We need a slice with length equal to input length to store LIS lengths at each index.

2. Step 2: Check each option

   lis := make([]int, len(nums)) creates a slice with length len(nums), ready to store values. lis := []int{} creates empty slice with length 0. var lis [len(nums)]int is invalid syntax for arrays with dynamic length. lis := make([]int, 0, len(nums)) creates slice with length 0 but capacity len(nums), so cannot index directly.

3. Final Answer:

   lis := make([]int, len(nums)) -> Option D

4. Quick Check:

   Slice with length = len(nums) for LIS storage [OK]

Hint: Use make with length for direct indexing [OK]

Common Mistakes:

• Using empty slice without length
• Trying to declare array with variable length
• Confusing capacity with length

3. What is the output of the following Go code that calculates the length of the LIS for nums := []int{10, 9, 2, 5, 3, 7, 101, 18}?

func lengthOfLIS(nums []int) int {
    lis := make([]int, len(nums))
    for i := range lis {
        lis[i] = 1
    }
    for i := 1; i < len(nums); i++ {
        for j := 0; j < i; j++ {
            if nums[i] > nums[j] && lis[i] < lis[j]+1 {
                lis[i] = lis[j] + 1
            }
        }
    }
    maxLen := 0
    for _, length := range lis {
        if length > maxLen {
            maxLen = length
        }
    }
    return maxLen
}

fmt.Println(lengthOfLIS(nums))

medium

A. 4

B. 3

C. 5

D. 6

Solution

1. Step 1: Initialize LIS array with 1s

   Each element starts with LIS length 1 (itself).

2. Step 2: Update LIS values by checking previous elements

   Check pairs (i,j) where nums[i] > nums[j], update lis[i] = max(lis[i], lis[j]+1).

3. Step 3: Calculate max LIS length

   For given nums, LIS is [2,3,7,101] length 4.

4. Final Answer:

   4 -> Option A

5. Quick Check:

   LIS length for example = 4 [OK]

Hint: Trace LIS updates for each element [OK]

Common Mistakes:

• Confusing subsequence with subarray
• Not updating lis[i] correctly
• Forgetting to initialize lis with 1

4. Identify the bug in this Go function that attempts to compute the LIS length:

func lengthOfLIS(nums []int) int {
    lis := make([]int, len(nums))
    for i := 0; i < len(nums); i++ {
        lis[i] = 0
    }
    for i := 1; i < len(nums); i++ {
        for j := 0; j < i; j++ {
            if nums[i] > nums[j] && lis[i] < lis[j] + 1 {
                lis[i] = lis[j] + 1
            }
        }
    }
    maxLen := 0
    for _, length := range lis {
        if length > maxLen {
            maxLen = length
        }
    }
    return maxLen
}

medium

A. lis slice is initialized with zeros instead of ones

B. The outer loop should start from 0 instead of 1

C. The condition nums[i] > nums[j] is incorrect

D. maxLen should be initialized to 1 instead of 0

Solution

1. Step 1: Check lis initialization

   lis should start with 1 for each element because each element alone is a subsequence of length 1.

2. Step 2: Effect of zero initialization

   Starting with 0 causes maxLen to be zero if no updates happen, giving wrong result.

3. Final Answer:

   lis slice is initialized with zeros instead of ones -> Option A

4. Quick Check:

   Initialize lis with 1, not 0 [OK]

Hint: Initialize LIS array elements to 1 [OK]

Common Mistakes:

• Starting lis values at 0
• Wrong loop start index
• Misunderstanding LIS condition

5. Given the sequence nums := []int{3, 10, 2, 1, 20}, which of the following is the correct longest increasing subsequence returned by a function that reconstructs the LIS (not just its length)?

hard

A. [2, 10, 20]

B. [3, 10, 20]

C. [1, 2, 20]

D. [3, 2, 20]

Solution

1. Step 1: Identify increasing subsequences

   Check subsequences where each next number is bigger than previous.

2. Step 2: Find longest valid subsequence

   Possible LIS are [3,10,20] and [1,20], but [3,10,20] is longer with length 3.

3. Step 3: Verify options

   [3, 10, 20] matches the longest increasing subsequence. [2, 10, 20] and C start with smaller numbers but 2 is after 10 in original, so invalid subsequence. [3, 2, 20] is not increasing.

4. Final Answer:

   [3, 10, 20] -> Option B

5. Quick Check:

   Longest increasing subsequence = [3, 10, 20] [OK]

Hint: Check order and increasing property carefully [OK]

Common Mistakes:

• Choosing subsequences not in original order
• Picking non-increasing sequences
• Confusing length with actual subsequence