# The Selection Problem

Save this PDF as:

Size: px
Start display at page:

## Transcription

1 The Selection Problem The selection problem: given an integer k and a list x 1,..., x n of n elements find the k-th smallest element in the list Example: the 3rd smallest element of the following list is An O(n log n) solution: sort the list (O(n log n)) pick the k-th element of the sorted list (O(1)) Can we find the k-th smallest element faster?

2 Quick-Select Quick-select of the k-th smallest element in the list S: based on prune-and-search paradigm Prune: pick random element x (pivot) from S and split S in: L elements < x, E elements == x, G elements > x Search: L E G partitioning into L, E and G works precisely as for quick-sort if k L then return quickselect(k, L) if L < k L + E then return x if k > L + E then return quickselect(k L E, G)

3 Quick-Select Visualization Quick-select can be displayed by a sequence of nodes: each node represents recursive call and stores: k, the sequence, and the pivot element k = 5, S = ( ) k = 2, S = ( ) k = 2, S = ( ) k = 1, S = (7 6 5) found 5

4 Quick-Select: Running Time The worst-case running is O(n 2 ) time: if the pivot is always the minimal or maximal element The expected running time is O(n) (compare with quick-sort): with probability 0.5 the recursive call is good: (3/4)n size T (n) b a n + T ( 3 4 n) a is the time steps for partitioning per element b is the expected number of calls until a good call b = 2 (average number of coins to toss until head shows up) Let m = 2 a n, then T (n) 2 a n + T ((3/4)n) 2 a n + 2 a (3/4) n + 2 a (3/4) 2 n... = 8 a n O(n) (geometric series)

5 Quick-Select: Median of Medians We can do selection in O(n) worst-case time. Idea: recursively use select itself to find a good pivot: divide S into n/5 sets of 5 elements find a median in each set (baby median) recursively use select to find the median of the medians min. size of L min. size of G 3 The minimal size of L and G is 0.3 n.

6 Quick-Select: Median of Medians We know: The minimal size of L and G is 0.3 n. Thus the maximal size of L and G is 0.7 n. Let b N such that: partitioning of a list of size n takes at most b n time, finding the baby medians takes at most b n time, the base case n 1 takes at most b time. We derive a recurrence equation for the time complexity: b if n 1 T (0.7 n) + T (0.2 n) + 2 b n if n > 1 We will see how to solve recurrence equations...

7 Fundamental Techniques We have considered algorithms for solving special problems. Now we consider a few fundamental techniques: Devide-and-Conquer The Greedy Method Dynamic Programming

8 Divide-and-Conquer Divide-and-Conquer is a general algorithm design paradigm: Divide: divide input S into k 2 disjoint subsets S 1,...,S k Recur: recursively solve the subproblems S 1,...,S k Conquer: combine solutions for S 1,...,S k to solution for S (the base case of the recursion are problems of size 0 or 1) We have already seen examples: merge sort quick sort bottom-up heap construction Focus now: analysing time complexity by recurrence equations.

9 Methods for Solving Recurrence Equation We consider 3 methods for solving recurrence equation: Iterative substitution method, Recursion tree method, Guess-and-test method, and Master method.

10 Iterative Substitution Iterative substitution technique works as follows: iteratively apply the recurrence equations to itself hope to find a pattern Example 1 if n 1 T (n 1) + 2 if n > 1 We start with T (n) and apply the recursive case: T (n 1) + 2 = T (n 2) + 4 = T (n k) + 2 k For k = n 1 we reach the base case T (n k) = 1 thus: (n 1) = 2 n 1

11 Merge-Sort Review Merge-sort of a list S with n elements works as follows: Divide: divide S into two lists S 1, S 2 of n/2 elements Recur: recursively sort S 1, S 2 Conquer: merge S 1 and S 2 into a sorting of S Let b N such that: merging two lists of size n/2 takes at most b n time, and the base case n 1 takes at most b time We obtain the following recurrence equation for merge-sort: b if n 1 2 T (n/2) + b n if n > 1 We search a closed solution for the equation, that is:... where T (n) does not occur in the right side

12 Example: Merge-Sort b if n 1 2 T (n/2) + b n if n > 1 We assume that n is a power of 2: n = 2 k (that is, k = log 2 n) allowed since we are interested in asymptotic behaviour We start with T (n) and apply the recursive case: 2 T (n/2) + b n = 2 (2 T (n/2 2 ) + b (n/2) ) + b n = 2 2 T (n/2 2 ) + 2 b n = 2 3 T (n/2 3 ) + 3 b n = 2 k T (n/2 k ) + k b n = n b + (log 2 n) b n Thus b (n + n log 2 n) O(n log 2 n).

13 The Recursion Tree Method The recursion tree method is a visual approach: draw the recursion tree and hope to find a pattern b if n 2 3 T (n/3) + b n if n > 2 For a node with input size k: work at this node is b k. depth nodes size 0 1 n 1 3 n/3 i 3 i n/3 i Thus the work at depth i is 3 i b n/3 i = b n. The height of the tree is log 3 n. Thus T (n) is O(n log 3 n).

14 Guess-and-Test Method The guess-and-test method works as follows: we guess a solution (or an upper bound) we prove that the solution is true by induction Example 1 if n 1 T (n/2) + 2 n if n > 1 Guess: T (n) 2 n for n = 1 it holds for n > 1 we have: T (n/2) + 2 n 2 n/2 + 2 n = 3 n Wrong guess: we cannot make 3 n smaller or equal to 2 n.

15 Example, continued 1 if n 1 T (n/2) + 2 n if n > 1 New guess: T (n) 4 n for n = 1 it holds for n > 1 we have: T (n/2) + 2 n 4 n/2 + 2 n = 4 n (by induction hypothesis) This time the guess was good: 4 n 4 n. Thus T (n) 4 n.

16 Example: Quick-Select with Median of Median b if n 1 T (0.7 n) + T (0.2 n) + 2 b n if n > 1 Guess: T (n) 20 b n for n = 1 it holds b 20 b 1 for n > 1 we have: T (0.7 n) + T (0.2 n) + 2 b n b n b n + 2 b n = b n + 2 b n = 18 b n + 2 b n = 20 b n (by IH) Thus the guess was good. This shows that quick-select with median of median is O(n).

17 Master method Many divide-and-conquer recurrence equations have the form: c if n < d at (n/b) + f (n) if n d Theorem (The Master Theorem) 1. if f (n) is O(n log b a ε ), then T (n) is Θ(n log b a ) 2. if f (n) is Θ(n log b a log k n), then T (n) is Θ(n log b a log k+1 n) 3. if f (n) is Ω(n log b a+ε ), then T (n) is Θ(f (n)), provided af (n/b) δf (n) for some δ < 1.

18 Master Method: Example 1 c at (n/b) + f (n) if n < d if n d Theorem (The Master Theorem) 1. if f (n) is O(n log b a ε ), then T (n) is Θ(n log b a ) 2. if f (n) is Θ(n log b a log k n), then T (n) is Θ(n log b a log k+1 n) 3. if f (n) is Ω(n log b a+ε ), then T (n) is Θ(f (n)), provided af (n/b) δf (n) for some δ < 1. Example 4 T (n/2) + n Solution: log b a = 2, thus case 1 says Θn 2.

19 Master Method: Example 2 c at (n/b) + f (n) if n < d if n d Theorem (The Master Theorem) 1. if f (n) is O(n log b a ε ), then T (n) is Θ(n log b a ) 2. if f (n) is Θ(n log b a log k n), then T (n) is Θ(n log b a log k+1 n) 3. if f (n) is Ω(n log b a+ε ), then T (n) is Θ(f (n)), provided af (n/b) δf (n) for some δ < 1. Example 2 T (n/2) + n log n Solution: log b a = 1, thus case 2 says Θn log 2 n.

20 Master Method: Example 3 c at (n/b) + f (n) if n < d if n d Theorem (The Master Theorem) 1. if f (n) is O(n log b a ε ), then T (n) is Θ(n log b a ) 2. if f (n) is Θ(n log b a log k n), then T (n) is Θ(n log b a log k+1 n) 3. if f (n) is Ω(n log b a+ε ), then T (n) is Θ(f (n)), provided af (n/b) δf (n) for some δ < 1. Example T (n/3) + n log n Solution: log b a = 0, thus case 3 says Θn log n.

21 Master Method: Example 4 c at (n/b) + f (n) if n < d if n d Theorem (The Master Theorem) 1. if f (n) is O(n log b a ε ), then T (n) is Θ(n log b a ) 2. if f (n) is Θ(n log b a log k n), then T (n) is Θ(n log b a log k+1 n) 3. if f (n) is Ω(n log b a+ε ), then T (n) is Θ(f (n)), provided af (n/b) δf (n) for some δ < 1. Example 8 T (n/2) + n 2 Solution: log b a = 3, thus case 1 says Θn 3.

22 Master Method: Example 5 c at (n/b) + f (n) if n < d if n d Theorem (The Master Theorem) 1. if f (n) is O(n log b a ε ), then T (n) is Θ(n log b a ) 2. if f (n) is Θ(n log b a log k n), then T (n) is Θ(n log b a log k+1 n) 3. if f (n) is Ω(n log b a+ε ), then T (n) is Θ(f (n)), provided af (n/b) δf (n) for some δ < 1. Example 9 T (n/3) + n 3 Solution: log b a = 2, thus case 3 says Θn 3.

23 Master Method: Example 6 c at (n/b) + f (n) if n < d if n d Theorem (The Master Theorem) 1. if f (n) is O(n log b a ε ), then T (n) is Θ(n log b a ) 2. if f (n) is Θ(n log b a log k n), then T (n) is Θ(n log b a log k+1 n) 3. if f (n) is Ω(n log b a+ε ), then T (n) is Θ(f (n)), provided af (n/b) δf (n) for some δ < 1. Example T (n/2) + 1 binary search Solution: log b a = 0, thus case 2 says Θlog n.

24 Master Method: Example 7 c at (n/b) + f (n) if n < d if n d Theorem (The Master Theorem) 1. if f (n) is O(n log b a ε ), then T (n) is Θ(n log b a ) 2. if f (n) is Θ(n log b a log k n), then T (n) is Θ(n log b a log k+1 n) 3. if f (n) is Ω(n log b a+ε ), then T (n) is Θ(f (n)), provided af (n/b) δf (n) for some δ < 1. Example 2 T (n/2) + log n heap construction Solution: log b a = 0, thus case 1 says Θn.

### Merge Sort. 2004 Goodrich, Tamassia. Merge Sort 1

Merge Sort 7 2 9 4 2 4 7 9 7 2 2 7 9 4 4 9 7 7 2 2 9 9 4 4 Merge Sort 1 Divide-and-Conquer Divide-and conquer is a general algorithm design paradigm: Divide: divide the input data S in two disjoint subsets

### Intro. to the Divide-and-Conquer Strategy via Merge Sort CMPSC 465 CLRS Sections 2.3, Intro. to and various parts of Chapter 4

Intro. to the Divide-and-Conquer Strategy via Merge Sort CMPSC 465 CLRS Sections 2.3, Intro. to and various parts of Chapter 4 I. Algorithm Design and Divide-and-Conquer There are various strategies we

### Divide-and-Conquer Algorithms Part Four

Divide-and-Conquer Algorithms Part Four Announcements Problem Set 2 due right now. Can submit by Monday at 2:15PM using one late period. Problem Set 3 out, due July 22. Play around with divide-and-conquer

### The Tower of Hanoi. Recursion Solution. Recursive Function. Time Complexity. Recursive Thinking. Why Recursion? n! = n* (n-1)!

The Tower of Hanoi Recursion Solution recursion recursion recursion Recursive Thinking: ignore everything but the bottom disk. 1 2 Recursive Function Time Complexity Hanoi (n, src, dest, temp): If (n >

### Quicksort is a divide-and-conquer sorting algorithm in which division is dynamically carried out (as opposed to static division in Mergesort).

Chapter 7: Quicksort Quicksort is a divide-and-conquer sorting algorithm in which division is dynamically carried out (as opposed to static division in Mergesort). The three steps of Quicksort are as follows:

### Sorting revisited. Build the binary search tree: O(n^2) Traverse the binary tree: O(n) Total: O(n^2) + O(n) = O(n^2)

Sorting revisited How did we use a binary search tree to sort an array of elements? Tree Sort Algorithm Given: An array of elements to sort 1. Build a binary search tree out of the elements 2. Traverse

### Binary Search. Search for x in a sorted array A.

Divide and Conquer A general paradigm for algorithm design; inspired by emperors and colonizers. Three-step process: 1. Divide the problem into smaller problems. 2. Conquer by solving these problems. 3.

### Divide and Conquer. Textbook Reading Chapters 4, 7 & 33.4

Divide d Conquer Textook Reading Chapters 4, 7 & 33.4 Overview Design principle Divide d conquer Proof technique Induction, induction, induction Analysis technique Recurrence relations Prolems Sorting

### CS473 - Algorithms I

CS473 - Algorithms I Lecture 4 The Divide-and-Conquer Design Paradigm View in slide-show mode 1 Reminder: Merge Sort Input array A sort this half sort this half Divide Conquer merge two sorted halves Combine

### Many algorithms, particularly divide and conquer algorithms, have time complexities which are naturally

Recurrence Relations Many algorithms, particularly divide and conquer algorithms, have time complexities which are naturally modeled by recurrence relations. A recurrence relation is an equation which

### Randomized algorithms

Randomized algorithms March 10, 2005 1 What are randomized algorithms? Algorithms which use random numbers to make decisions during the executions of the algorithm. Why would we want to do this?? Deterministic

### CSC148 Lecture 8. Algorithm Analysis Binary Search Sorting

CSC148 Lecture 8 Algorithm Analysis Binary Search Sorting Algorithm Analysis Recall definition of Big Oh: We say a function f(n) is O(g(n)) if there exists positive constants c,b such that f(n)

### Introduction to Algorithms March 10, 2004 Massachusetts Institute of Technology Professors Erik Demaine and Shafi Goldwasser Quiz 1.

Introduction to Algorithms March 10, 2004 Massachusetts Institute of Technology 6.046J/18.410J Professors Erik Demaine and Shafi Goldwasser Quiz 1 Quiz 1 Do not open this quiz booklet until you are directed

### Outline BST Operations Worst case Average case Balancing AVL Red-black B-trees. Binary Search Trees. Lecturer: Georgy Gimel farb

Binary Search Trees Lecturer: Georgy Gimel farb COMPSCI 220 Algorithms and Data Structures 1 / 27 1 Properties of Binary Search Trees 2 Basic BST operations The worst-case time complexity of BST operations

### Closest Pair Problem

Closest Pair Problem Given n points in d-dimensions, find two whose mutual distance is smallest. Fundamental problem in many applications as well as a key step in many algorithms. p q A naive algorithm

### Format of Divide-and-Conquer algorithms:

CS 360: Data Structures and Algorithms Divide-and-Conquer (part 1) Format of Divide-and-Conquer algorithms: Divide: Split the array or list into smaller pieces Conquer: Solve the same problem recursively

### Divide And Conquer Algorithms

CSE341T/CSE549T 09/10/2014 Lecture 5 Divide And Conquer Algorithms Recall in last lecture, we looked at one way of parallelizing matrix multiplication. At the end of the lecture, we saw the reduce SUM

### CS 102: SOLUTIONS TO DIVIDE AND CONQUER ALGORITHMS (ASSGN 4)

CS 10: SOLUTIONS TO DIVIDE AND CONQUER ALGORITHMS (ASSGN 4) Problem 1. a. Consider the modified binary search algorithm so that it splits the input not into two sets of almost-equal sizes, but into three

### CS473 - Algorithms I

CS473 - Algorithms I Lecture 9 Sorting in Linear Time View in slide-show mode 1 How Fast Can We Sort? The algorithms we have seen so far: Based on comparison of elements We only care about the relative

### Converting a Number from Decimal to Binary

Converting a Number from Decimal to Binary Convert nonnegative integer in decimal format (base 10) into equivalent binary number (base 2) Rightmost bit of x Remainder of x after division by two Recursive

### Mergesort and Quicksort

Mergesort Mergesort and Quicksort Basic plan: Divide array into two halves. Recursively sort each half. Merge two halves to make sorted whole. mergesort mergesort analysis quicksort quicksort analysis

### Binary Heaps * * * * * * * / / \ / \ / \ / \ / \ * * * * * * * * * * * / / \ / \ / / \ / \ * * * * * * * * * *

Binary Heaps A binary heap is another data structure. It implements a priority queue. Priority Queue has the following operations: isempty add (with priority) remove (highest priority) peek (at highest

### Week 7: Divide and Conquer

Agenda: Divide and Conquer technique Multiplication of large integers Exponentiation Matrix multiplication 1 2- Divide and Conquer : To solve a problem we can break it into smaller subproblems, solve each

### Simplified Analyses of Randomized Algorithms for Searching, Sorting, and Selection

Simplified Analyses of Randomized Algorithms for Searching, Sorting, and Selection i Michael T. Goodrich Roberto Tamassia Dept. of Info. & Computer Science Dept. of Computer Science University of California

### the recursion-tree method

the recursion- method recurrence into a 1 recurrence into a 2 MCS 360 Lecture 39 Introduction to Data Structures Jan Verschelde, 22 November 2010 recurrence into a The for consists of two steps: 1 Guess

### Introduction to Algorithms Review information for Prelim 1 CS 4820, Spring 2010 Distributed Wednesday, February 24

Introduction to Algorithms Review information for Prelim 1 CS 4820, Spring 2010 Distributed Wednesday, February 24 The final exam will cover seven topics. 1. greedy algorithms 2. divide-and-conquer algorithms

### CMPS 102 Solutions to Homework 1

CMPS 0 Solutions to Homework Lindsay Brown, lbrown@soe.ucsc.edu September 9, 005 Problem..- p. 3 For inputs of size n insertion sort runs in 8n steps, while merge sort runs in 64n lg n steps. For which

### Near Optimal Solutions

Near Optimal Solutions Many important optimization problems are lacking efficient solutions. NP-Complete problems unlikely to have polynomial time solutions. Good heuristics important for such problems.

### CSE 326, Data Structures. Sample Final Exam. Problem Max Points Score 1 14 (2x7) 2 18 (3x6) 3 4 4 7 5 9 6 16 7 8 8 4 9 8 10 4 Total 92.

Name: Email ID: CSE 326, Data Structures Section: Sample Final Exam Instructions: The exam is closed book, closed notes. Unless otherwise stated, N denotes the number of elements in the data structure

### The Union-Find Problem Kruskal s algorithm for finding an MST presented us with a problem in data-structure design. As we looked at each edge,

The Union-Find Problem Kruskal s algorithm for finding an MST presented us with a problem in data-structure design. As we looked at each edge, cheapest first, we had to determine whether its two endpoints

### Analysis of Algorithms I: Binary Search Trees

Analysis of Algorithms I: Binary Search Trees Xi Chen Columbia University Hash table: A data structure that maintains a subset of keys from a universe set U = {0, 1,..., p 1} and supports all three dictionary

### A Note on Maximum Independent Sets in Rectangle Intersection Graphs

A Note on Maximum Independent Sets in Rectangle Intersection Graphs Timothy M. Chan School of Computer Science University of Waterloo Waterloo, Ontario N2L 3G1, Canada tmchan@uwaterloo.ca September 12,

### To My Parents -Laxmi and Modaiah. To My Family Members. To My Friends. To IIT Bombay. To All Hard Workers

To My Parents -Laxmi and Modaiah To My Family Members To My Friends To IIT Bombay To All Hard Workers Copyright 2010 by CareerMonk.com All rights reserved. Designed by Narasimha Karumanchi Printed in

### SORTING. Review of Sorting. Merge Sort. Sets. sorting

Review of Sorting Merge Sort Sets SORTING 1 Sorting Algorithms Selection Sort uses a priority queue P implemented with an unsorted sequence: - Phase 1: the insertion of an item into P takes O(1) time;

### Full and Complete Binary Trees

Full and Complete Binary Trees Binary Tree Theorems 1 Here are two important types of binary trees. Note that the definitions, while similar, are logically independent. Definition: a binary tree T is full

### Algorithms. Margaret M. Fleck. 18 October 2010

Algorithms Margaret M. Fleck 18 October 2010 These notes cover how to analyze the running time of algorithms (sections 3.1, 3.3, 4.4, and 7.1 of Rosen). 1 Introduction The main reason for studying big-o

### CMSC 451 Design and Analysis of Computer Algorithms 1

CMSC 4 Design and Analysis of Computer Algorithms David M. Mount Department of Computer Science University of Maryland Fall 003 Copyright, David M. Mount, 004, Dept. of Computer Science, University of

### CS335 Program2: ConvexHulls A Divide-and-Conquer Algorithm 15 points Due: Tues, October 6

CS335 Program2: ConvexHulls A Divide-and-Conquer Algorithm 15 points Due: Tues, October 6 Convex Hulls There is a complex mathematical definition of a convex hull, but the informal definition is sufficient

### APP INVENTOR. Test Review

APP INVENTOR Test Review Main Concepts App Inventor Lists Creating Random Numbers Variables Searching and Sorting Data Linear Search Binary Search Selection Sort Quick Sort Abstraction Modulus Division

### Lecture 1: Course overview, circuits, and formulas

Lecture 1: Course overview, circuits, and formulas Topics in Complexity Theory and Pseudorandomness (Spring 2013) Rutgers University Swastik Kopparty Scribes: John Kim, Ben Lund 1 Course Information Swastik

### Sorting algorithm. Sorting algorithms used in computer science are often classified by:

Sorting algorithm In computer science and mathematics, a sorting algorithm is an algorithm that puts elements of a list in a certain order. The most used orders are numerical order and lexicographical

### 1) The postfix expression for the infix expression A+B*(C+D)/F+D*E is ABCD+*F/DE*++

Answer the following 1) The postfix expression for the infix expression A+B*(C+D)/F+D*E is ABCD+*F/DE*++ 2) Which data structure is needed to convert infix notations to postfix notations? Stack 3) The

### DESIGN AND ANALYSIS OF ALGORITHMS

CPS 3 DESIGN AND ANALYSIS OF ALGORITHMS Fall 8 Instructor: Herbert Edelsbrunner Teaching Assistant: Zhiqiang Gu CPS 3 Fall Semester of 8 Table of Contents Introduction 3 I DESIGN TECHNIQUES Divide-and-Conquer

### K-Cover of Binary sequence

K-Cover of Binary sequence Prof Amit Kumar Prof Smruti Sarangi Sahil Aggarwal Swapnil Jain Given a binary sequence, represent all the 1 s in it using at most k- covers, minimizing the total length of all

### 2.3 Scheduling jobs on identical parallel machines

2.3 Scheduling jobs on identical parallel machines There are jobs to be processed, and there are identical machines (running in parallel) to which each job may be assigned Each job = 1,,, must be processed

### 1/1 7/4 2/2 12/7 10/30 12/25

Binary Heaps A binary heap is dened to be a binary tree with a key in each node such that: 1. All leaves are on, at most, two adjacent levels. 2. All leaves on the lowest level occur to the left, and all

### Divide-and-conquer algorithms

Chapter 2 Divide-and-conquer algorithms The divide-and-conquer strategy solves a problem by: 1 Breaking it into subproblems that are themselves smaller instances of the same type of problem 2 Recursively

### Polynomials and the Fast Fourier Transform (FFT) Battle Plan

Polynomials and the Fast Fourier Transform (FFT) Algorithm Design and Analysis (Wee 7) 1 Polynomials Battle Plan Algorithms to add, multiply and evaluate polynomials Coefficient and point-value representation

### Data Structures and Algorithms Written Examination

Data Structures and Algorithms Written Examination 22 February 2013 FIRST NAME STUDENT NUMBER LAST NAME SIGNATURE Instructions for students: Write First Name, Last Name, Student Number and Signature where

### Sorting Algorithms. Nelson Padua-Perez Bill Pugh. Department of Computer Science University of Maryland, College Park

Sorting Algorithms Nelson Padua-Perez Bill Pugh Department of Computer Science University of Maryland, College Park Overview Comparison sort Bubble sort Selection sort Tree sort Heap sort Quick sort Merge

### Section IV.1: Recursive Algorithms and Recursion Trees

Section IV.1: Recursive Algorithms and Recursion Trees Definition IV.1.1: A recursive algorithm is an algorithm that solves a problem by (1) reducing it to an instance of the same problem with smaller

### Binary Heap Algorithms

CS Data Structures and Algorithms Lecture Slides Wednesday, April 5, 2009 Glenn G. Chappell Department of Computer Science University of Alaska Fairbanks CHAPPELLG@member.ams.org 2005 2009 Glenn G. Chappell

### Approximation Algorithms

Approximation Algorithms or: How I Learned to Stop Worrying and Deal with NP-Completeness Ong Jit Sheng, Jonathan (A0073924B) March, 2012 Overview Key Results (I) General techniques: Greedy algorithms

Divide and Conquer Paradigm Melissa Manley California State University Northridge Author s address: 18111 Nordhoff Street, Northridge, CA, 91330 Permission to make digital/hard copy of all or part of this

### 8.1 Makespan Scheduling

600.469 / 600.669 Approximation Algorithms Lecturer: Michael Dinitz Topic: Dynamic Programing: Min-Makespan and Bin Packing Date: 2/19/15 Scribe: Gabriel Kaptchuk 8.1 Makespan Scheduling Consider an instance

### Cost Model: Work, Span and Parallelism. 1 The RAM model for sequential computation:

CSE341T 08/31/2015 Lecture 3 Cost Model: Work, Span and Parallelism In this lecture, we will look at how one analyze a parallel program written using Cilk Plus. When we analyze the cost of an algorithm

### Offline sorting buffers on Line

Offline sorting buffers on Line Rohit Khandekar 1 and Vinayaka Pandit 2 1 University of Waterloo, ON, Canada. email: rkhandekar@gmail.com 2 IBM India Research Lab, New Delhi. email: pvinayak@in.ibm.com

### Lecture 4 Online and streaming algorithms for clustering

CSE 291: Geometric algorithms Spring 2013 Lecture 4 Online and streaming algorithms for clustering 4.1 On-line k-clustering To the extent that clustering takes place in the brain, it happens in an on-line

### Algorithm Design and Analysis Homework #1 Due: 5pm, Friday, October 4, 2013 TA email: ada@csie.ntu.edu.tw. === Homework submission instructions ===

Algorithm Design and Analysis Homework #1 Due: 5pm, Friday, October 4, 2013 TA email: ada@csie.ntu.edu.tw === Homework submission instructions === For Problem 1, commit your source code and a brief documentation

### Algorithms and Data Structures

Algorithm Analysis Page 1 BFH-TI: Softwareschule Schweiz Algorithm Analysis Dr. CAS SD01 Algorithm Analysis Page 2 Outline Course and Textbook Overview Analysis of Algorithm Pseudo-Code and Primitive Operations

### PARALLEL PROGRAMMING

PARALLEL PROGRAMMING TECHNIQUES AND APPLICATIONS USING NETWORKED WORKSTATIONS AND PARALLEL COMPUTERS 2nd Edition BARRY WILKINSON University of North Carolina at Charlotte Western Carolina University MICHAEL

### Induction. Margaret M. Fleck. 10 October These notes cover mathematical induction and recursive definition

Induction Margaret M. Fleck 10 October 011 These notes cover mathematical induction and recursive definition 1 Introduction to induction At the start of the term, we saw the following formula for computing

### Recurrences and the Complexity of Divide and Conquer Algorithms

2006 Antonio Crznig Recurrences nd the Complexity of Divide nd Conquer Algorithms Antonio Crznig Fculty of Informtics Università dell Svizzer itlin October 12, 2010 2006 Antonio Crznig Outline Anlysis

### Exam study sheet for CS2711. List of topics

Exam study sheet for CS2711 Here is the list of topics you need to know for the final exam. For each data structure listed below, make sure you can do the following: 1. Give an example of this data structure

### Analysis of Algorithms I: Optimal Binary Search Trees

Analysis of Algorithms I: Optimal Binary Search Trees Xi Chen Columbia University Given a set of n keys K = {k 1,..., k n } in sorted order: k 1 < k 2 < < k n we wish to build an optimal binary search

### Questions 1 through 25 are worth 2 points each. Choose one best answer for each.

Questions 1 through 25 are worth 2 points each. Choose one best answer for each. 1. For the singly linked list implementation of the queue, where are the enqueues and dequeues performed? c a. Enqueue in

### Dynamic Programming. Lecture 11. 11.1 Overview. 11.2 Introduction

Lecture 11 Dynamic Programming 11.1 Overview Dynamic Programming is a powerful technique that allows one to solve many different types of problems in time O(n 2 ) or O(n 3 ) for which a naive approach

### princeton univ. F 13 cos 521: Advanced Algorithm Design Lecture 6: Provable Approximation via Linear Programming Lecturer: Sanjeev Arora

princeton univ. F 13 cos 521: Advanced Algorithm Design Lecture 6: Provable Approximation via Linear Programming Lecturer: Sanjeev Arora Scribe: One of the running themes in this course is the notion of

### Divide-and-Conquer. Three main steps : 1. divide; 2. conquer; 3. merge.

Divide-and-Conquer Three main steps : 1. divide; 2. conquer; 3. merge. 1 Let I denote the (sub)problem instance and S be its solution. The divide-and-conquer strategy can be described as follows. Procedure

### External Sorting. Chapter 13. Database Management Systems 3ed, R. Ramakrishnan and J. Gehrke 1

External Sorting Chapter 13 Database Management Systems 3ed, R. Ramakrishnan and J. Gehrke 1 Why Sort? A classic problem in computer science! Data requested in sorted order e.g., find students in increasing

### Zabin Visram Room CS115 CS126 Searching. Binary Search

Zabin Visram Room CS115 CS126 Searching Binary Search Binary Search Sequential search is not efficient for large lists as it searches half the list, on average Another search algorithm Binary search Very

### 28 Closest-Point Problems -------------------------------------------------------------------

28 Closest-Point Problems ------------------------------------------------------------------- Geometric problems involving points on the plane usually involve implicit or explicit treatment of distances

### 1 2-3 Trees: The Basics

CS10: Data Structures and Object-Oriented Design (Fall 2013) November 1, 2013: 2-3 Trees: Inserting and Deleting Scribes: CS 10 Teaching Team Lecture Summary In this class, we investigated 2-3 Trees in

### Biostatistics 615/815

Merge Sort Biostatistics 615/815 Lecture 8 Notes on Problem Set 2 Union Find algorithms Dynamic Programming Results were very ypositive! You should be gradually becoming g y g comfortable compiling, debugging

### Divide and Conquer Examples. Top-down recursive mergesort. Gravitational N-body problem.

Divide and Conquer Divide the problem into several subproblems of equal size. Recursively solve each subproblem in parallel. Merge the solutions to the various subproblems into a solution for the original

### 2. (a) Explain the strassen s matrix multiplication. (b) Write deletion algorithm, of Binary search tree. [8+8]

Code No: R05220502 Set No. 1 1. (a) Describe the performance analysis in detail. (b) Show that f 1 (n)+f 2 (n) = 0(max(g 1 (n), g 2 (n)) where f 1 (n) = 0(g 1 (n)) and f 2 (n) = 0(g 2 (n)). [8+8] 2. (a)

### 6 March 2007 1. Array Implementation of Binary Trees

Heaps CSE 0 Winter 00 March 00 1 Array Implementation of Binary Trees Each node v is stored at index i defined as follows: If v is the root, i = 1 The left child of v is in position i The right child of

### MODULAR ARITHMETIC. a smallest member. It is equivalent to the Principle of Mathematical Induction.

MODULAR ARITHMETIC 1 Working With Integers The usual arithmetic operations of addition, subtraction and multiplication can be performed on integers, and the result is always another integer Division, on

### CS5310 Algorithms 3 credit hours 2 hours lecture and 2 hours recitation every week

CS5310 Algorithms 3 credit hours 2 hours lecture and 2 hours recitation every week This course is a continuation of the study of data structures and algorithms, emphasizing methods useful in practice.

### Small Maximal Independent Sets and Faster Exact Graph Coloring

Small Maximal Independent Sets and Faster Exact Graph Coloring David Eppstein Univ. of California, Irvine Dept. of Information and Computer Science The Exact Graph Coloring Problem: Given an undirected

### Learning Example. Machine learning and our focus. Another Example. An example: data (loan application) The data and the goal

Learning Example Chapter 18: Learning from Examples 22c:145 An emergency room in a hospital measures 17 variables (e.g., blood pressure, age, etc) of newly admitted patients. A decision is needed: whether

### 6. Standard Algorithms

6. Standard Algorithms The algorithms we will examine perform Searching and Sorting. 6.1 Searching Algorithms Two algorithms will be studied. These are: 6.1.1. inear Search The inear Search The Binary

### Balanced Binary Search Tree

AVL Trees / Slide 1 Balanced Binary Search Tree Worst case height of binary search tree: N-1 Insertion, deletion can be O(N) in the worst case We want a tree with small height Height of a binary tree with

### Data Structures Fibonacci Heaps, Amortized Analysis

Chapter 4 Data Structures Fibonacci Heaps, Amortized Analysis Algorithm Theory WS 2012/13 Fabian Kuhn Fibonacci Heaps Lacy merge variant of binomial heaps: Do not merge trees as long as possible Structure:

### External Memory Geometric Data Structures

External Memory Geometric Data Structures Lars Arge Department of Computer Science University of Aarhus and Duke University Augues 24, 2005 1 Introduction Many modern applications store and process datasets

### From Last Time: Remove (Delete) Operation

CSE 32 Lecture : More on Search Trees Today s Topics: Lazy Operations Run Time Analysis of Binary Search Tree Operations Balanced Search Trees AVL Trees and Rotations Covered in Chapter of the text From

### 6.2 Permutations continued

6.2 Permutations continued Theorem A permutation on a finite set A is either a cycle or can be expressed as a product (composition of disjoint cycles. Proof is by (strong induction on the number, r, of

### Cpt S 223. School of EECS, WSU

Priority Queues (Heaps) 1 Motivation Queues are a standard mechanism for ordering tasks on a first-come, first-served basis However, some tasks may be more important or timely than others (higher priority)

### 5.4 Closest Pair of Points

5.4 Closest Pair of Points Closest Pair of Points Closest pair. Given n points in the plane, find a pair with smallest Euclidean distance between them. Fundamental geometric primitive. Graphics, computer

### , each of which contains a unique key value, say k i , R 2. such that k i equals K (or to determine that no such record exists in the collection).

The Search Problem 1 Suppose we have a collection of records, say R 1, R 2,, R N, each of which contains a unique key value, say k i. Given a particular key value, K, the search problem is to locate the

### International Journal of Advanced Research in Computer Science and Software Engineering

Volume 3, Issue 7, July 23 ISSN: 2277 28X International Journal of Advanced Research in Computer Science and Software Engineering Research Paper Available online at: www.ijarcsse.com Greedy Algorithm:

### Lecture 6 Online and streaming algorithms for clustering

CSE 291: Unsupervised learning Spring 2008 Lecture 6 Online and streaming algorithms for clustering 6.1 On-line k-clustering To the extent that clustering takes place in the brain, it happens in an on-line

### Clustering UE 141 Spring 2013

Clustering UE 141 Spring 013 Jing Gao SUNY Buffalo 1 Definition of Clustering Finding groups of obects such that the obects in a group will be similar (or related) to one another and different from (or

### Decision-Tree Learning

Decision-Tree Learning Introduction ID3 Attribute selection Entropy, Information, Information Gain Gain Ratio C4.5 Decision Trees TDIDT: Top-Down Induction of Decision Trees Numeric Values Missing Values

### Treemaps with bounded aspect ratio

technische universiteit eindhoven Department of Mathematics and Computer Science Master s Thesis Treemaps with bounded aspect ratio by Vincent van der Weele Supervisor dr. B. Speckmann Eindhoven, July

### Information Theory and Coding Prof. S. N. Merchant Department of Electrical Engineering Indian Institute of Technology, Bombay

Information Theory and Coding Prof. S. N. Merchant Department of Electrical Engineering Indian Institute of Technology, Bombay Lecture - 17 Shannon-Fano-Elias Coding and Introduction to Arithmetic Coding

### Heaps & Priority Queues in the C++ STL 2-3 Trees

Heaps & Priority Queues in the C++ STL 2-3 Trees CS 3 Data Structures and Algorithms Lecture Slides Friday, April 7, 2009 Glenn G. Chappell Department of Computer Science University of Alaska Fairbanks

### Lecture 18: Applications of Dynamic Programming Steven Skiena. Department of Computer Science State University of New York Stony Brook, NY 11794 4400

Lecture 18: Applications of Dynamic Programming Steven Skiena Department of Computer Science State University of New York Stony Brook, NY 11794 4400 http://www.cs.sunysb.edu/ skiena Problem of the Day