A collection of programs

A type of software

A collection of data

A type of computer

Increasing the available memory

Converting the recursion to iterative form to use less memory

Reducing the problem size

Using a more efficient memoization strategy

The recursive calls are too deep

The memoization table consumes too much memory

There are not enough subproblems

The problem does not exhibit overlapping subproblems

The algorithm does not consider all possible subsets of tasks

The algorithm makes irreversible decisions based on local optima without considering the entire problem

The tasks are not sorted correctly before the algorithm is applied

The algorithm incorrectly calculates the finish times of tasks

By selecting activities randomly until no more can be chosen

By choosing the shortest activities first

By selecting the activities that start the earliest, without overlapping

By choosing the activities that leave the most free time after completion

Memoization

Randomization

Backtracking

Linear search

By placing queens one by one in different rows and checking for conflicts at each step

By randomly placing queens on the board and rearranging them to resolve conflicts

By using a greedy algorithm to place all queens simultaneously

By calculating the exact positions of all queens before placing them

To guarantee the best solution to problems

To provide a deterministic time complexity for any given problem

To improve the average-case performance of algorithms by introducing randomness

To simplify the implementation of algorithms

To provide the exact solution to NP-hard problems

To provide solutions that are close to the best possible answer for NP-hard problems

To reduce the time complexity of algorithms to polynomial time

To convert NP-hard problems into P problems

Greedy algorithms make a sequence of choices that may not lead to an optimal solution, while dynamic programming ensures an optimal solution by considering all possible solutions

Greedy algorithms are easier to implement than dynamic programming solutions

Greedy algorithms can solve a wider range of problems than dynamic programming

Dynamic programming is only suitable for problems with a linear structure

Dynamic programming requires that the problem has overlapping subproblems, whereas divide and conquer does not

Dynamic programming uses only recursion, while divide and conquer does not

Dynamic programming is used only for optimization problems

Divide and conquer algorithms are not applicable to problems with optimal substructure

A technique for finding the shortest path in a graph

A way to conserve memory by deleting unnecessary data

A recursive method for solving combinatorial problems by trying to build a solution incrementally

A data compression method

Simplifying a problem by breaking it into smaller, more manageable parts

Increasing the efficiency of sorting algorithms

Optimizing recursive functions

Balancing binary search trees

Frequent splaying of the same nodes

Not splaying at every operation

Incorrectly balancing the tree

Overuse of rotations in splay operations

Nodes for some letters are not correctly linked

The search function does not correctly handle word endings

Case sensitivity issues

A and B

The heapify process is not correctly implemented

The heap is not balanced correctly after operations

Keys are not compared correctly during insertions

All of the above

By swapping the new element with the root if it's smaller

By placing the new element in the leftmost available position and then "heapifying" up

By sorting the entire heap after each insertion

By replacing the largest element if the new element is smaller

Finding the maximum value

Insertion

Deletion

Finding the minimum value

Create a new node for every character of the key and link them

Reuse existing nodes for the key if they match and create new nodes only when necessary

Insert the key at the root

B and C

It provides the worst-case time complexity for any single operation

It shows the average time complexity over a sequence of operations

It guarantees constant time complexity for all operations

It reduces the space complexity of the data structure