Scribd
Upload
126 views

35 Algorithm Types

The document discusses various types of algorithms, including: - Recursive algorithms that break problems into simpler subproblems. - Backtracking algorithms that use depth-first search and backtracking. - Divide and conquer algorithms that break problems into subproblems, solve the subproblems recursively, and combine the solutions. - Greedy algorithms that make locally optimal choices at each step to find a global optimum. - Brute force algorithms that exhaustively check all possibilities to find a solution.

Uploaded by

Zaigham Abbas
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
126 views

35 Algorithm Types

The document discusses various types of algorithms, including: - Recursive algorithms that break problems into simpler subproblems. - Backtracking algorithms that use depth-first search and backtracking. - Divide and conquer algorithms that break problems into subproblems, solve the subproblems recursively, and combine the solutions. - Greedy algorithms that make locally optimal choices at each step to find a global optimum. - Brute force algorithms that exhaustively check all possibilities to find a solution.

Uploaded by

Zaigham Abbas
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 14

Types of Algorithms

Algorithm classification
Algorithms that use a similar problem-solving approach can be grouped together This classification scheme is neither exhaustive nor disjoint The purpose is not to be able to classify an algorithm as one type or another, but to highlight the various ways in which a problem can be attacked

A short list of categories


Algorithm types we will consider include:
Simple recursive algorithms Backtracking algorithms Divide and conquer algorithms Dynamic programming algorithms Greedy algorithms Branch and bound algorithms Brute force algorithms Randomized algorithms

Simple recursive algorithms I


A simple recursive algorithm:
Solves the base cases directly Recurs with a simpler subproblem Does some extra work to convert the solution to the simpler subproblem into a solution to the given problem

I call these simple because several of the other algorithm types are inherently recursive

Example recursive algorithms


To count the number of elements in a list:
If the list is empty, return zero; otherwise, Step past the first element, and count the remaining elements in the list Add one to the result

To test if a value occurs in a list:


If the list is empty, return false; otherwise, If the first thing in the list is the given value, return true; otherwise Step past the first element, and test whether the value occurs in the remainder of the list

Backtracking algorithms
Backtracking algorithms are based on a depth-first recursive search A backtracking algorithm:
Tests to see if a solution has been found, and if so, returns it; otherwise For each choice that can be made at this point, Make that choice Recur If the recursion returns a solution, return it If no choices remain, return failure

Example backtracking algorithm


To color a map with no more than four colors:
color(Country n) If all countries have been colored (n > number of countries) return success; otherwise, For each color c of four colors, If country n is not adjacent to a country that has been colored c Color country n with color c recursivly color country n+1 If successful, return success Return failure (if loop exits)

Divide and Conquer


A divide and conquer algorithm consists of two parts:
Divide the problem into smaller subproblems of the same type, and solve these subproblems recursively Combine the solutions to the subproblems into a solution to the original problem

Traditionally, an algorithm is only called divide and conquer if it contains two or more recursive calls

Examples
Quicksort:
Partition the array into two parts, and quicksort each of the parts No additional work is required to combine the two sorted parts

Mergesort:
Cut the array in half, and mergesort each half Combine the two sorted arrays into a single sorted array by merging them

Fibonacci numbers
To find the nth Fibonacci number:
If n is zero or one, return one; otherwise, Compute fibonacci(n-1) and fibonacci(n-2) Return the sum of these two numbers

This is an expensive algorithm


It requires O(fibonacci(n)) time This is equivalent to exponential time, that is, O(2n)

Greedy algorithms
An optimization problem is one in which you want to find, not just a solution, but the best solution A greedy algorithm sometimes works well for optimization problems A greedy algorithm works in phases: At each phase:
You take the best you can get right now, without regard for future consequences You hope that by choosing a local optimum at each step, you will end up at a global optimum

Example: Counting money


Suppose you want to count out a certain amount of money, using the fewest possible bills and coins A greedy algorithm would do this would be: At each step, take the largest possible bill or coin that does not overshoot
Example: To make $6.39, you can choose: a $5 bill a $1 bill, to make $6 a 25 coin, to make $6.25 A 10 coin, to make $6.35 four 1 coins, to make $6.39

For US money, the greedy algorithm always gives the optimum solution

Brute force algorithm


A brute force algorithm simply tries all possibilities until a satisfactory solution is found
Such an algorithm can be: Optimizing: Find the best solution. This may require finding all solutions, or if a value for the best solution is known, it may stop when any best solution is found
Example: Finding the best path for a travelling salesman

Satisficing: Stop as soon as a solution is found that is good enough


Example: Finding a travelling salesman path that is within 10% of optimal

Improving brute force algorithms


Often, brute force algorithms require exponential time Various heuristics and optimizations can be used
Heuristic: A rule of thumb that helps you decide which possibilities to look at first Optimization: In this case, a way to eliminate certain possibilites without fully exploring them

You might also like