In DFS, what data structure is typically used to keep track of visited nodes?
- Heap
- Linked List
- Queue
- Stack
In Depth-First Search (DFS), a stack is typically used to keep track of visited nodes. The stack follows the Last In, First Out (LIFO) principle, ensuring that the last node visited is the first one to be explored.
How can memoization be used to optimize the computation of Fibonacci numbers?
- By implementing a randomized algorithm to generate Fibonacci numbers.
- By sorting the Fibonacci sequence in ascending order before computation.
- By storing previously computed Fibonacci numbers in a table and reusing them to avoid redundant calculations.
- By using a divide and conquer approach to split the Fibonacci sequence into smaller subproblems.
Memoization optimizes the computation of Fibonacci numbers by storing previously calculated values in a table (memory). When a Fibonacci number is needed, the algorithm first checks if it's already in the table, and if so, retrieves the precomputed value, avoiding redundant recursive calculations.
An efficient way to handle deletions in a hash table is to use a _______ value to mark deleted entries, allowing for proper rehashing.
- Null
- Sentinel
- Special marker
- Unique key
An efficient way to handle deletions in a hash table is to use a special marker value to mark deleted entries. This allows for proper rehashing and ensures that the deleted entries are correctly accounted for during subsequent operations.
Which of the following best describes the selection sort algorithm?
- Algorithm based on priority queues
- In-place algorithm with no comparisons
- Recursive algorithm using subproblems
- Sorting algorithm that divides the list into two parts: sorted and unsorted
The selection sort algorithm is a simple sorting algorithm that divides the input list into two parts: a sorted and an unsorted portion. It repeatedly selects the smallest (or largest) element from the unsorted part and swaps it with the first element of the unsorted part.
Merge sort is a _______ sorting algorithm that follows the _______ strategy.
- Bubble
- Divide and Conquer
- Dynamic Programming
- Greedy
Merge sort is a Divide and Conquer sorting algorithm that follows the Divide and Conquer strategy. It recursively divides the array into two halves, sorts them, and then merges them back together.
Explain why binary search is more efficient than linear search for large datasets.
- Binary search always finds the element in the first comparison
- Binary search can only be used with small datasets
- Binary search divides the search space in half at each step, reducing the time complexity to O(log n)
- Linear search has a time complexity of O(n^2)
Binary search is more efficient for large datasets because it divides the search space in half at each step, resulting in a time complexity of O(log n), which is significantly faster than linear search (O(n)).
BFS guarantees finding the shortest path in an unweighted graph because it explores nodes in _______ order.
- Increasing
- Lexicographical
- Non-decreasing
- Non-increasing
BFS guarantees finding the shortest path in an unweighted graph because it explores nodes in increasing order. As it systematically traverses nodes level by level, the first time a node is encountered, it is reached through the shortest path.
How can the longest common substring problem be extended to handle multiple strings?
- Apply the algorithm separately to each pair of strings and combine the results.
- Extend dynamic programming to a multidimensional array to account for multiple strings.
- Longest common substring problem cannot be extended to handle multiple strings.
- Utilize greedy algorithms to find common substrings among multiple strings.
To handle multiple strings in the longest common substring problem, dynamic programming can be extended to a multidimensional array. This array helps store the common substrings for each pair of strings, and the results can then be combined.
The Longest Increasing Subsequence problem can be efficiently solved using _______.
- Binary Search
- Bubble Sort
- Depth-First Search
- QuickSort
The Longest Increasing Subsequence (LIS) problem can be efficiently solved using Binary Search. The binary search approach allows us to find the length of the LIS in an optimized way, reducing the time complexity.
The time complexity of the dynamic programming solution for the coin change problem is _______.
- O(n * m)
- O(n log n)
- O(n)
- O(n^2)
The time complexity of the dynamic programming solution for the coin change problem is O(n * m), where 'n' is the target amount and 'm' is the number of coin denominations. This is because the dynamic programming table has dimensions n x m, and each entry is filled in constant time.