'Finding the shortest path' is correct. Breadth-First Search (BFS) explores a graph level by level using a Queue, making it ideal for finding the shortest path in an unweighted graph.

'BFS finds shortest path in unweighted graphs' is correct. Breadth-First Search (BFS) explores a graph level by level using a Queue, making it ideal for finding the shortest path in an unweighted graph.

'Unweighted graph' is correct. Breadth-First Search (BFS) explores a graph level by level using a Queue, making it ideal for finding the shortest path in an unweighted graph.

'Queue' is correct. Breadth-First Search (BFS) explores a graph level by level using a Queue, making it ideal for finding the shortest path in an unweighted graph.

'Nodes level by level' is correct. Breadth-First Search (BFS) explores a graph level by level using a Queue, making it ideal for finding the shortest path in an unweighted graph.

'When list is unsorted' is correct. Binary search operates in O(log n) time by repeatedly dividing a sorted list in half, making it vastly more efficient than linear search for large sorted datasets.

'O(log n)' is correct. Big O notation is used in computer science to classify algorithms according to how their run time or space requirements grow as the input size grows.

'When list is small or unsorted' is correct. Binary search operates in O(log n) time by repeatedly dividing a sorted list in half, making it vastly more efficient than linear search for large sorted datasets.

'Better time complexity O(log n)' is correct. Binary search operates in O(log n) time by repeatedly dividing a sorted list in half, making it vastly more efficient than linear search for large sorted datasets.

'Checks each item one by one' is correct. Binary search operates in O(log n) time by repeatedly dividing a sorted list in half, making it vastly more efficient than linear search for large sorted datasets.

'Easy to understand but not efficient for large datasets' is correct. Sorting algorithms like Bubble and Selection Sort have O(n²) complexity, making them simple but inefficient for large datasets compared to O(n log n) algorithms like Merge Sort.

'O(n²) time complexity' is correct. Sorting algorithms like Bubble and Selection Sort have O(n²) complexity, making them simple but inefficient for large datasets compared to O(n log n) algorithms like Merge Sort.

'O(n²)' is correct. Big O notation is used in computer science to classify algorithms according to how their run time or space requirements grow as the input size grows.

'Boundary between sorted/unsorted moves forward' is correct. Sorting algorithms like Bubble and Selection Sort have O(n²) complexity, making them simple but inefficient for large datasets compared to O(n log n) algorithms like Merge Sort.

'Finds the smallest in the unsorted section and swaps it' is correct. Sorting algorithms like Bubble and Selection Sort have O(n²) complexity, making them simple but inefficient for large datasets compared to O(n log n) algorithms like Merge Sort.

'Simple to understand and implement' is correct. Sorting algorithms like Bubble and Selection Sort have O(n²) complexity, making them simple but inefficient for large datasets compared to O(n log n) algorithms like Merge Sort.

'High time complexity O(n²)' is correct. Sorting algorithms like Bubble and Selection Sort have O(n²) complexity, making them simple but inefficient for large datasets compared to O(n log n) algorithms like Merge Sort.

'O(n²)' is correct. Big O notation is used in computer science to classify algorithms according to how their run time or space requirements grow as the input size grows.

'They are swapped' is correct. Sorting algorithms like Bubble and Selection Sort have O(n²) complexity, making them simple but inefficient for large datasets compared to O(n log n) algorithms like Merge Sort.

'Adjacent elements' is correct. Sorting algorithms like Bubble and Selection Sort have O(n²) complexity, making them simple but inefficient for large datasets compared to O(n log n) algorithms like Merge Sort.

'Merge Sort' is correct. An algorithm is a finite, step-by-step sequence of instructions designed to solve a specific problem efficiently.

'Time taken as a function of input size' is correct. Big O notation is used in computer science to classify algorithms according to how their run time or space requirements grow as the input size grows.

'O(V + E)' is correct. Big O notation is used in computer science to classify algorithms according to how their run time or space requirements grow as the input size grows.

'Bubble Sort' is correct. An algorithm is a finite, step-by-step sequence of instructions designed to solve a specific problem efficiently.

'Quick Sort' is correct. An algorithm is a finite, step-by-step sequence of instructions designed to solve a specific problem efficiently.

'Exploring a maze' is correct. Backtracking is an algorithmic technique that builds solutions incrementally and abandons ('backtracks' from) partial solutions that cannot lead to a valid complete solution.

'Try an option, and if it fails, undo and try another' is correct. Backtracking is an algorithmic technique that builds solutions incrementally and abandons ('backtracks' from) partial solutions that cannot lead to a valid complete solution.

'Problems with many possible combinations' is correct. Backtracking is an algorithmic technique that builds solutions incrementally and abandons ('backtracks' from) partial solutions that cannot lead to a valid complete solution.

'Solving a Sudoku puzzle' is correct. Backtracking is an algorithmic technique that builds solutions incrementally and abandons ('backtracks' from) partial solutions that cannot lead to a valid complete solution.

'Goes back to the last choice and tries another' is correct. Backtracking is an algorithmic technique that builds solutions incrementally and abandons ('backtracks' from) partial solutions that cannot lead to a valid complete solution.

'Tables or arrays' is correct. Dynamic Programming optimizes recursive algorithms by storing the results of overlapping subproblems, thus avoiding redundant calculations.

'Time is wasted on recalculations' is correct. Dynamic Programming optimizes recursive algorithms by storing the results of overlapping subproblems, thus avoiding redundant calculations.

'Overlapping subproblems and optimal substructure' is correct. Dynamic Programming optimizes recursive algorithms by storing the results of overlapping subproblems, thus avoiding redundant calculations.

'Calculating Fibonacci numbers' is correct. Dynamic Programming optimizes recursive algorithms by storing the results of overlapping subproblems, thus avoiding redundant calculations.

'Results of subproblems' is correct. Dynamic Programming optimizes recursive algorithms by storing the results of overlapping subproblems, thus avoiding redundant calculations.

'Similar and can be solved independently' is correct. Divide and Conquer involves breaking a problem into smaller, independent sub-problems, solving them recursively, and combining their results (e.g., Merge Sort).

'They are combined to form the final solution' is correct. Divide and Conquer involves breaking a problem into smaller, independent sub-problems, solving them recursively, and combining their results (e.g., Merge Sort).

'Merge Sort' is correct. An algorithm is a finite, step-by-step sequence of instructions designed to solve a specific problem efficiently.

'Breaks a problem into smaller problems to solve it' is correct. Divide and Conquer involves breaking a problem into smaller, independent sub-problems, solving them recursively, and combining their results (e.g., Merge Sort).

'Divide' is correct. Divide and Conquer involves breaking a problem into smaller, independent sub-problems, solving them recursively, and combining their results (e.g., Merge Sort).

'Independent and similar in nature' is correct. Divide and Conquer involves breaking a problem into smaller, independent sub-problems, solving them recursively, and combining their results (e.g., Merge Sort).

'Problems that can be divided into smaller, similar problems' is correct. Divide and Conquer involves breaking a problem into smaller, independent sub-problems, solving them recursively, and combining their results (e.g., Merge Sort).

'We combine their results' is correct. Divide and Conquer involves breaking a problem into smaller, independent sub-problems, solving them recursively, and combining their results (e.g., Merge Sort).

'Merge Sort' is correct. Divide and Conquer involves breaking a problem into smaller, independent sub-problems, solving them recursively, and combining their results (e.g., Merge Sort).

'Divide' is correct. Divide and Conquer involves breaking a problem into smaller, independent sub-problems, solving them recursively, and combining their results (e.g., Merge Sort).

'Problems with overlapping subproblems and optimal substructure' is correct. Dynamic Programming optimizes recursive algorithms by storing the results of overlapping subproblems, thus avoiding redundant calculations.

'Binary search' is correct. An algorithm is a finite, step-by-step sequence of instructions designed to solve a specific problem efficiently.

'Measuring time and space complexity' is correct. Big O notation is used in computer science to classify algorithms according to how their run time or space requirements grow as the input size grows.

'O(n²)' is correct. Big O notation is used in computer science to classify algorithms according to how their run time or space requirements grow as the input size grows.

'O(1)' is correct. Big O notation is used in computer science to classify algorithms according to how their run time or space requirements grow as the input size grows.

'Time grows linearly with input' is correct. Big O notation is used in computer science to classify algorithms according to how their run time or space requirements grow as the input size grows.

'They require infinite time to solve' is correct. The Halting Problem, proven unsolvable by Alan Turing, demonstrates that no general algorithm can determine if every possible program will eventually halt.

'Alan Turing' is correct. The Halting Problem, proven unsolvable by Alan Turing, demonstrates that no general algorithm can determine if every possible program will eventually halt.

'No algorithm can solve it for all input cases' is correct. The Halting Problem, proven unsolvable by Alan Turing, demonstrates that no general algorithm can determine if every possible program will eventually halt.

'Calculating the GCD of two numbers' is correct. The Halting Problem, proven unsolvable by Alan Turing, demonstrates that no general algorithm can determine if every possible program will eventually halt.

'It can be solved using a finite algorithm' is correct. The Halting Problem, proven unsolvable by Alan Turing, demonstrates that no general algorithm can determine if every possible program will eventually halt.

'They eliminate the need for testing solutions' is correct. An algorithm is a finite, step-by-step sequence of instructions designed to solve a specific problem efficiently.

'Heuristics' is the correct answer. Understanding this concept is crucial for algorithm design and problem-solving.

'The number of possible solutions is small' is correct. An algorithm is a finite, step-by-step sequence of instructions designed to solve a specific problem efficiently.

'Generate and test' is correct. An algorithm is a finite, step-by-step sequence of instructions designed to solve a specific problem efficiently.

'A step-by-step method for solving a problem' is correct. An algorithm is a finite, step-by-step sequence of instructions designed to solve a specific problem efficiently.

'Checking if a number is prime' is the correct answer. Understanding this concept is crucial for algorithm design and problem-solving.

'Input, process, output' is correct. A well-defined computational problem has clear inputs, processes, and outputs, which are essential for algorithmic solutions.

'A sequence of steps to solve a problem' is correct. An algorithm is a finite, step-by-step sequence of instructions designed to solve a specific problem efficiently.

'Output' is the correct answer. Understanding this concept is crucial for algorithm design and problem-solving.

'A set of steps or rules' is correct. A well-defined computational problem has clear inputs, processes, and outputs, which are essential for algorithmic solutions.

'Input' is correct. A well-defined computational problem has clear inputs, processes, and outputs, which are essential for algorithmic solutions.

'A challenge solved using an algorithm' is correct. A well-defined computational problem has clear inputs, processes, and outputs, which are essential for algorithmic solutions.

'Clear goals, inputs, processes, and outputs' is correct. A well-defined computational problem has clear inputs, processes, and outputs, which are essential for algorithmic solutions.