Brute Force: Selection Sort

Size: px

Start display at page:

Download "Brute Force: Selection Sort"

Candice May
5 years ago
Views:

1 Brute Force: Intro Brute force means straightforward approach Usually based directly on problem s specs Force refers to computational power Usually not as efficient as elegant solutions Advantages: Applicable to wide variety of problems May produce reasonable algorithm of practical value with no limitation on instance size Expense of generating elegant solution may not be justified Handy for small-size problems Are the basis by which other algorithms can be compared 1

2 Brute Force: Selection Sort Algorithm: SS(A[0..n - 1]) { \\Input: Array A[0..n - 1] \\Output: Sorted array for ( i <- 0 to n - 2) { min <- i for ( j <- i + 1 to n - 1) if (A[j] < A[min] min <- j swap A[i], A[min] Analysis: Size = number of elements (n) Basic op is comparison (A[j] < A[min]) Work depends only on n C(n) = n 2 i=0 n 1 j=i+1 1 = n 2 i=0 [(n 1) (i + 1) + 1] = n 2 i=0 (n 1 i) = (n 1)n 2 SS Θ(n 2 ) Number of swaps Θ(n 2 ) 2

3 Brute Force: Bubble Sort Algorithm: BS(A[0..n - 1]) { \\Input: Array A[0..n - 1] \\Output: Sorted array for ( i <- 0 to n - 2) { for ( j <- 0 to n i) if (A[j + 1] < A[j] swap A[i], A[j + 1] Analysis: Size = number of elements (n) Basic op is comparison (A[j + 1] < A[j]) Work depends only on n C(n) = n 2 i=0 n 2 i j=0 1 = n 2 i=0 [(n 2 i) 0 + 1] = n 2 i=0 (n 1 i) = (n 1)n 2 BS Θ(n 2 ) Number of swaps depends on instance: worst case Θ(n 2 )) Can improve by keeping track of swaps 3

4 Brute Force: Sequential Search Algorithm: SqS(A[0..n - 1], k) { \\Input: Array A[0..n] on n elements in slots 0.. n - 1, search key k \\Output: Index i to k (or -1) A[n] <- k i <- 0 while( A[i]!= k) i++ if (i < n) return i else return -1 Analysis: See chapter 2 4

5 Brute Force: String Matching Problem: Given text string of n characters and pattern string of m characters, find i - the leftmost index of pattern in text Algorithm: BFSM(T[0..n - 1], P[0..m - 1]) { \\Input: String T[0..n - 1] and pattern P[0..m - 1] \\Output: Index i to P s position in T (or -1) for ( i <- 0 to n - m) { j <- 0 while ( j < m AND P[j] == T[i + j]) j++ if (j == m) return i return -1 Analysis: Size = number of elements (n) Basic op is comparison (P [j] = T [i + j]) Work depends only on instance Usually, shift occurs after 1 comparison Worst case makes m comparisons per index: Θ(mn) Average case: Θ(n + m) = Θ(n) 5

6 Brute Force: Closest Pair Problem Problem: Given a set of n planar points, find 2 such that the distance between them is the shortest between any pair of points in the set Algorithm: BFCP(P) { \\Input: Array P[1..n] of points \\Output: Indices index1, index2 to closest points dmin <- infinity for ( i <- 1 to n - 1) for ( j <- i + 1 to n) { d <- sqrt((p[i].x - P[j].x)^2 + (P[i].y - P[j].y)^2) // More efficiently: d <- ((P[i].x - P[j].x)^2 + (P[i].y - P[j].y)^2) if (d < dmin) { dmin <- d index1 <- i index2 <- j return index1, index2 Analysis: Size = number of points (n) Basic op is calculating distance Work depends only on n C(n) = n 1 i=1 nj=i+1 2 = 2 n 1 i=1 (n i) = 2[(n 1) + (n 2) ] = n(n 1) BF CP Θ(n 2 ) 6

7 Brute Force: Convex Hull Problem Basic concepts: Convex set of coplanar points is set such that a line between any 2 of the points falls entirely within the set Convex hull of n coplanar points is the smallest convex polygon that contains all n points Extreme point is a vertex of a convex hull Theorem: The convex hull of set S of n > 2 points (not all colinear) is a convex polygon with vertices at some points of S The convex hull problem: Given n points, construct a convex hull for the points; i.e., find the extreme points of the encompassing polygon The basic approach: 2 points of set S form an edge of the convex hull of S if all of the remaining points fall on the same side of the line connecting the 2 points Given points p 1 (x 1, y 1 ), p 2 (x 2, y 2 ), the line through them is defined by ax + by = c, where a = y 2 y 1, b = x 1 x 2, c = x 1 y 2 y 1 x 2 For an arbitrary point p i (x i, y i ) p i is on the line if ax i + by i = c p i is on one side of the line or the other if ax i + by i < c or ax i + by i > c To determine extreme points: For each n(n 1) 2 pairs of points, determine the sign of ax + by c for the remaining n 2 points ch(n) Θ(n 3 ) 7

8 Brute Force: Exhaustive Search Brute force approach to combinatorial problems: 1. Generate each element of domain 2. Select those that meet criteria 3. Select solution This section ignores generation of combinatorial objects 8

9 Brute Force: Traveling Salesman Problem Given a set of cities and roads between them, determine the cheapest route that visits each city exactly once. Represent as a weighted graph Vertices represent cities Edges represent paths Edge weights represent costs Problem reduces to finding shortest Hamiltonian circuit of graph Brute force approach: For each node, find all possible node sequences that begin and end at the node. This consists of the initial node and all permutations of the remaining n - 1 nodes Only 1/2 of these need be considered Number of permutations = (n 1)! 2 9

10 Brute Force: Knapsack Problem Given a container of capacity x and n items of capacity c i and value v i, find the set of items of greatest value that can fit into the container. For example: item size value Brute force approach examines all possible subsets of the n items, selecting the one with greatest value Number of subsets (power set) of n items is 2 n ks(n) Ω(2 n ) 10

11 Brute Force: Assignment Problem Given n people and n tasks, with each person assigned a rating for each task, find the best way of assigning the tasks to the people. For example: person tasks Most natural representation is a matrix Solution is an n-tuple, with 1 value from each column, no 2 of which come from the same row Select solution from permutations of 1..n (row numbers) ap(n) Ω(n!) 11

12 Basic approach: Decrease and Conquer: Depth-First Graph Traversal 1. From the root, follow a path to a leaf 2. When dead-end at a leaf, backtrack to nearest ancestor with unexplored branches and repeat Explores the tree branch-by-branch Algorithm: Alg DFT (G) { //Input: Graph G = {V, E //Output: Graph G with vertices numbered in order of visitation mark each vertex with 0 count <- 0 for (each vertex v in V) if (v marked 0) dft(v) Alg dft (v) { //Input: Vertex v, count //Output: Marked vertices, updated count count++ mark v with count for (each vertex w adjacent to v) if (w marked 0) dft(w) Iterative version uses a programmer-controlled stack, pushing vertices when first visited, popping when all children expanded Can create a depth-first forest during traversal: When encounter unvisited vertex, create edge from parent to vertex called tree edge When encounter visited vertex, create edge from it to parent called back edge The parent node is an ancestor of the vertex in the search forest Graph of search forest same as original with vertices partitioned into 2 sets (tree and back edges) 12

13 Decrease and Conquer: Depth-First Search (2) Analysis: Order of growth depends on data structure used to represent graph For adjacency matrix: Θ( V 2 ) For linked list: Θ( V + E ) Order in which nodes visited and exited are distinct and can be used in other algs DFT can test for connectivity by determining if any vertices remain unmarked after exit 1st vertex DFT can test for cycles by determining if any back edges exist 13

14 Basic approach: Decrease and Conquer: Breadth-First Traversal 1. From the root, visit each child 2. Repeat, visiting the immediate children of each of the above nodes;... Explores the graph level-by-level Algorithm: Alg BFT (G) { //Input: Graph G = {V, E //Output: Graph G with vertices numbered in order of visitation mark each vertex v in V with 0 count <- 0 for (each vertex v in V) if (v marked 0) bft(v) Alg bft (v) { //Input: Vertex v, count //Output: Marked vertices, updated count count++ mark v with count add v to queue while (queue NOT empty) { v <- front of queue for (each vertex w adjacent to v) if (w marked 0) { count++ mark w with count add w to queue Analysis: Order of growth is same as for depth-first Vertices exited in same order as first visited Can be used for connectivity and cycles just like depth-first Finds shortest path from root to given vertex Can create breadth-first forest in same manner as for depth-first traversal No back edges Previously marked vertices constitute cross edges Are links to siblings of either parent or vertex itself 14

15 Decrease and Conquer: DFT/BFT Comparison DFT BFT Data structure stack queue No. vertex orders 2 1 Edge types tree tree back cross Apps connectivity connectivity acyclicity acyclicity articulation points min-edge paths Efficiency: adj mat Θ( V 2 ) Θ( V 2 ) Efficiency: lnk lst Θ( V + E ) Θ( V + E ) 15

16 Decrease and Conquer: Digraphs Have direction associated with edge Represented same way as undirected graphs except Adjacency matrix usually not symmetric Linked list has just 1 node per edge DFT and BDT both apply DFT forest can have 4 edge types: 1. Tree edge 2. Back edge - can link to parent 3. Forward edge - links to descendent 4. Cross edge - None of the above Back edge indicates cycle Directed Acyclic Graph (DAG) is directed graph with no cycles 16

CSC Design and Analysis of Algorithms. Lecture 4 Brute Force, Exhaustive Search, Graph Traversal Algorithms. Brute-Force Approach

CSC Design and Analysis of Algorithms. Lecture 4 Brute Force, Exhaustive Search, Graph Traversal Algorithms. Brute-Force Approach CSC 8301- Design and Analysis of Algorithms Lecture 4 Brute Force, Exhaustive Search, Graph Traversal Algorithms Brute-Force Approach Brute force is a straightforward approach to solving a problem, usually