# CS 4310 HOMEWORK SET 1

Save this PDF as:

Size: px
Start display at page:

## Transcription

1 CS 4310 HOMEWORK SET 1 PAUL MILLER Section 2.1 Exercises Exercise Using Figure 2.2 as a model, illustrate the operation of INSERTION-SORT on the array A = 31, 41, 59, 26, 41, 58. Solution: Assume A is indexed from 1. Begin with A = [31, 41, 59, 26, 41, 58]. Since A[2] is already in the right spot relative to A[1], we do nothing when j = 2. Similarly, since A[3] is already in the right spot relative to A[1]...A[2], we do nothing again when j = 3. For j = 4, we find that A[4] == 26 is out of place, so we move it to its proper location in front of 31 and shift the other elements over to the right, giving A = [26, 31, 41, 59, 41, 58]. For j = 5, we find that A[5] == 41 is out of place, so we move it to its proper place in front of the previous instance of 41 and shift elements over to accommodate it, giving A = [26, 31, 41, 41, 59, 58]. Finally, for j = 6, we find A[6] == 58 is out of place, so we put it in its place and shift elements over to accommodate it, giving us finally A = [26, 31, 41, 41, 58, 59], the sorted sequence. Exercise Consider the searching problem: Input: A sequence of n numbers A = a 1, a 2,..., a n and a value v. Output: An index i such that v = A[i] or the special value NIL if v does not appear in A. Write pseudocode for linear search, which scans through the sequence, looking for v. Using a loop invariant, prove that your algorithm is correct. Make sure that your loop invariant fulfills the three necessary properties. Solution: The following Python code implements linear search: Date: October 1,

2 2 PAUL MILLER 1 def linear_ search ( A, v): 2 for i in range ( len (A)): 3 if A[i] == v: 4 return i 5 return NIL (Note that range (len (A)) returns a list of integers from 0 to len (A)-1, inclusive. Also, Python arrays are indexed from 0, so an array of length n has indices 0... n 1.) To show correctness, we shall use the following loop invariant: v {A[0], A[1],..., A[i 1]}. Initialization: At the beginning of the first iteration, we have i = 0, so the statement is empty. Maintenance: Suppose the invariant is not maintained after the k-th iteration. We would then have some i k 1 such that A[i] = v. However, in that case, the code would have returned the value i already, so there would not actually be a k-th iteration. This contradiction shows our initial assumption was incorrect, so the invariant is, in fact, maintained by the loop. Termination: Since the loop is a for loop over a finite sequence 0...len (A)-1, the loop will always terminate. If the algorithm finds v in the array A, we have A[i] = v, so the loop invariant is true (and the algorithm returns the index i). Otherwise, the loop terminates after len (A) iterations, in which case the invariant states that v {A[0],..., A[len(A) 1]}, which is the whole array A, so the invariant is again true, and the algorithm returns NIL. Therefore, the function linear search is correct by the loop invariant. Section 2.2 Exercises Exercise Express the function n 3 / n 2 100n + 3 in terms of Θ-notation. Solution: Note: This is a badly worded problem. As written, I can write n 3 / n 2 100n + 3 = Θ(n 3 / n 2 100n + 3). A

3 CS 4310 HOMEWORK SET 1 3 better rephrasing would be to find all values of c for which n 3 / n 2 100n + 3 = Θ(n c ). Since n 3 / n 2 100n if c = 3, = 0 if c > 3, and n n c if c < 3, we have that n 3 / n 2 100n+3 = Θ(n c ) if and only if c = 3. Exercise Consider sorting n numbers stored in array A by first finding the smallest element of A and exchanging it with the element in A[1]. Then find the second smallest element of A, and exchange it with A[2]. Continue in this manner for the first n 1 elements of A. Write pseudocode for this algorithm, which is known as selection sort. What loop invariant does this algorithm maintain? Why does it need to run for only the first n 1 elements, rather than for all n elements? Give the best-case and worst-case running times of selection sort in Θ-notation. Solution: The following pseudocode implements selection sort: 1 def index_of_min (A): 2 smallest = 0 3 i = 0 4 while i < len (A): 5 if A[i] < A[ smallest ]: 6 smallest = i 7 i += 1 8 return smallest 9 10 def selection_sort (A): 11 i = 0 12 while i < len ( A) - 1: 13 # A[i:] indicates A[i], A[i+1], j = index_of_min (A[i:]) + i # Swaps A[ i] and A[j] 17 A[i], A[j] = A[j], A[i] 18 i += 1 19 return A This algorithm maintains the loop invariant that after i iterations, the subarray consisting of the first i elements of the array A is sorted.

4 4 PAUL MILLER Indeed, after 1 iteration, the first 1 elements of the array are sorted, since we have swapped the previous value of A[0] with min (A) (if necessary). The invariant is maintained because on the i-th iteration, we swap A[i-1] with min (A[i-1:]) (if necessary). It only needs to run for the first n 1 elements of A because after the first n 1 elements of A are sorted, the last element is guaranteed to be in the correct position. (If it were not, this would imply that the first n 1 elements were not in sorted order, contradicting the loop invariant.) This then shows that the array is sorted upon termination of the loop. Since we must examine every element of an unsorted array to find the index of the minimum value, the function index of min must always examine all n elements of an n-element array. Thus, selection sort always uses n n + n 1 + n = j = n(n + 1)/2 comparisons to sort the array. Thus, selection sort uses Θ(n 2 ) comparisons in both the best and worst cases. j=1 Section 2.3 Exercises Exercise Using Figure 2.4 as a model, illustrate the operation of merge sort on the array A = 3, 41, 52, 26, 38, 57, 9, 49. Solution: At the bottom level, we have eight subarrays of length 1: [3], [41], [52], [26], [38], [57], [9], [49]. These are then merged to form four sorted subarrays of length 2: [3, 41], [26, 52], [38, 57], [9, 49]. (Note: when merging, we always merge consecutive pairs of smaller subarrays according to Figure 2-4. In reality, it does not matter which pairs of sorted subarrays we merge this is simply the order in which the algorithm does things as presented in the text.) These then get merged to form two subarrays of length 4: [3, 26, 41, 52], [9, 38, 49, 57]. Finally, these are merged to form a single subarray of length 8: [3, 9, 26, 38, 41, 49, 52, 57],

5 CS 4310 HOMEWORK SET 1 5 and we are done. Exercise Use mathematical induction to show that when n is an exact power of 2, the solution of the recurrence { 2 if n = 2, T (n) = 2T (n/2) + n if n = 2 k for k > 1 is T (n) = n lg n. Solution: Since T (2) = 2 lg 2 = 2 = 2 1 by substitution, the base case holds. For the induction hypothesis, assume that T (2 k ) = 2 k lg 2 k. By the definition of our recurrence, for n = 2 k+1, we then have that T (2 k+1 ) = 2T (2 k ) + 2 k+1. By the induction hypothesis, T (2 k ) = 2 k lg 2 k, so T (2 k+1 ) = 2(2 k lg 2 k ) + 2 k+1 = 2 k+1 (lg 2 k + 1) = 2 k+1 lg 2 k+1, which is what we were after, so the result follows by induction. Exercise Referring back to the searching problem (see Exercise 2.1-3), observe that if the sequence A is sorted, we can check the midpoint of the sequence against v and einate half of the sequence from further consideration. Binary search is an algorithm that repeats this procedure, halving the size of the remaining portion of the sequence each time. Write pseudocode, either iterative or recursive, for binary search. Argue that the worst-case running time of binary search is Θ(lg n). Solution: The following pseudocode implements a recursive binary search, returning the index of the element v if it is present, or the value None if it is not found: 1 def binary_ search( A, v, low, high): 2 if low > high: 3 return None 4 mid = ( low + high) / 2 5 if A[mid ] < v:

6 6 PAUL MILLER 6 return binary_ search ( A, v, mid + 1, high) 7 elif A[ mid] > v: 8 return binary_ search ( A, v, low, mid - 1) 9 else: 10 return mid Since the algorithm einates at least 1/2 of the possible indices under consideration at each step, after at most lg n steps, we will have either found the value v or determined that it is not in the array. Thus, the algorithm terminates after at most Θ(lg n) steps. Exercise Problem 2-3. The following code fragment implements Horner s rule for evaluating a polynomial P (x) = n a k x k = a 0 + x(a 1 + x(a x(a n 1 + xa n ) )), given the coefficients a 0, a 1,..., a n and a value for x: 1 y 0 2 i n 3 while i 0 4 do y a i + x y 5 i i 1 1. What is the asymptotic running time of this code fragment for Horner s rule? 2. Write pseudocode to implement the naive polynomial-evaluation algorithm that computes each term of the polynomial from scratch. What is the running time of this algorithm? How does it compare to Horner s rule? 3. Prove that the following is a loop invariant for the while loop in lines 3-5. At the start of each iteration of the while loop of lines 3-5, y = n (i+1) a k+i+1 x k

7 CS 4310 HOMEWORK SET 1 7 Interpret a summation with no terms as equaling 0. Your proof should follow the structure of the loop invariant proof presented in this chapter and should show that, at termination, y = n a kx k. 4. Conclude by arguing that the given code fragment correctly evaluates a polynomial characterized by the coefficients a 0, a 1,..., a n. Solution: 1. This algorithm does precisely two additions and one multiplication per iteration of the while loop. Since the while loop terminates after n iterations, it follows that Horner s rule computes P (x) using 2n additions and n multiplications, hence Θ(n) time. 2. The following pseudocode implements the naïve polynomial evaluation algorithm. The sequence a is assumed to contain the coefficients of P (x). 1 def naive_ poly ( a, x): 2 k = len (a) 3 if k == 1: 4 return a[0] 5 j = 1 6 for i in range (k- 1): 7 j *= x 8 return a[k- 1] * j + naive_poly (a[ 0:k-1], x) For a polynomial of degree n, this algorithm always does precisely j multiplications to compute the a j x j term, and precisely n 1 additions in total. Thus, the algorithm does n 1 + n = n(n + 1)/2 multiplications and n 1 additions, implying this algorithm uses Θ(n 2 ) operations. 3. At the start of the first iteration, we have i = n and y = 0, so n (i+1) 1 a k+i+1 x k = a k+n+1 x k = 0 because the sum is empty, so the loop invariant holds. Suppose i = j with 0 j < k at the beginning of an iteration. By our loop invariant, we have y = n (j+1) a k+j+1 x k at the beginning of the iteration. The algorithm then sets y to a j + x n (j+1) a k+j+1 x k = a j x 0 + n (j+1) a k+j+1 x k+1.

8 8 PAUL MILLER Next, the algorithm decrements i, so we now have j = i + 1. Thus, the previous expression becomes a i+1 x 0 + n (i+1+1) a k+(i+1)+1 x k+1 = a i+1 x 0 + = a i+1 x 0 + = n (i+1) m=0 n (i+2) n (i+1) m=1 a m+i+1 x m, a k+i+2 x k+1 a m+i+1 x m so the invariant is maintained. Finally, at termination, we have i = 1, so the value of y is n ( 1+1) a k+ 1+1 x m = n a k x k, 4. Since the final value of y is n a kx k, we conclude that this algorithm correctly evaluates the polynomial P (x) = a 0 + a 1 x + + a n 1 x n 1 + a n x n. Big O problems 1 For each pair of functions f(n), g(n), determine which of the following apply: (a) f(n) = Θ(g(n)), (b) f(n) = O(g(n)) but f(n) Θ(g(n)), or (c) f(n) = Ω(g(n)) but f(n) Θg(n). Exercise 1. f(n) = 100n + log n, g(n) = n + (log n) 2. Solution: Since 100n + log n n n + (log n) /n n 1 + (2 log n)/n = 100, (by L Hôpital s rule) by the theorem given in class (see, e.g., the text by Brainerd & Landweber), we have f(n) = Θ(g(n)). 1 Not part of Homework Set 1; from the text by Udi Manber.

9 CS 4310 HOMEWORK SET 1 9 Exercise 2. f(n) = log(n), g(n) = log(n 2 ). Solution: Since g(n) = 2 log(n) = 2f(n), we have f(n) = Θ(g(n)). Exercise 3. f(n) = n 2 /(log n), g(n) = n(log n) 2. Solution: Since n 2 /(log n) n n(log n) n 2 n (log n) 3 1 n 3(log n) 2 /n n n 3(log n) 2 1 n n 1 n 6/n 6(log n)/n n 6 log n n n 6 =, ( by L Hôpital s rule) (by L Hôpital s rule yet again) the theorem from class tells us that f(n) = Ω(g(n)) but f(n) Θ(g(n)). Exercise 4. f(n) = (log n) log n, g(n) = n/(log n). Solution: Let n = e u for some u. We then have f(n) = u u and g(n) = (log u)/u. Then, f(n) g(n) = u u (log u)/u = uu 1 log u.

10 10 PAUL MILLER Since u u 1 increases faster than u, and u u log u u u u =, 1 1/u we know u f(n)/g(n) n f(n)/g(n) =. theorem tells us that f(n) = Ω(g(n)) but f(n) Θ(g(n)). Hence, our Exercise 5. f(n) = n 1/2, g(n) = (log n) 5. Solution: Substituting n = e 2u, we get that f(n) g(n) = eu 32u 5. Applying L Hôpital s rule five times sequentially, we finally get u e u 32u 5 u e u 32 5! = f(n) n g(n), so our theorem tells us that f(n) = Ω(g(n)) but f(n) Θ(g(n)). Exercise 6. f(n) = n2 n, g(n) = 3 n. Solution: Since f(n)/g(n) = n(2/3) n, substituting n = log 2/3 u, we get We thus conclude that n f(n) g(n) = u log 2/3 u. f(n) g(n) u u log 2/3 u =, therefore, we have f(n) = Ω(g(n)) but f(n) Θ(g(n)).

### 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

### 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

### Analysis of Binary Search algorithm and Selection Sort algorithm

Analysis of Binary Search algorithm and Selection Sort algorithm In this section we shall take up two representative problems in computer science, work out the algorithms based on the best strategy to

### 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

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

### Algorithms, Integers

CHAPTER 3 Algorithms, Integers 3.1. Algorithms Consider the following list of instructions to find the maximum of three numbers a, b, c: 1. Assign variable x the value of a. 2. If b > x then assign x the

### 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:

### 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

### 3. Mathematical Induction

3. MATHEMATICAL INDUCTION 83 3. Mathematical Induction 3.1. First Principle of Mathematical Induction. Let P (n) be a predicate with domain of discourse (over) the natural numbers N = {0, 1,,...}. If (1)

### Why? A central concept in Computer Science. Algorithms are ubiquitous.

Analysis of Algorithms: A Brief Introduction Why? A central concept in Computer Science. Algorithms are ubiquitous. Using the Internet (sending email, transferring files, use of search engines, online

### Analysis of Algorithms: The Non-recursive Case

Analysis of Algorithms: The Non-recursive Case Key topics: * Introduction * Generalizing Running Time * Doing a Timing Analysis * Big-Oh Notation * Big-Oh Operations * Analyzing Some Simple Programs -

### CSE373: Data Structures and Algorithms Lecture 3: Math Review; Algorithm Analysis. Linda Shapiro Winter 2015

CSE373: Data Structures and Algorithms Lecture 3: Math Review; Algorithm Analysis Linda Shapiro Today Registration should be done. Homework 1 due 11:59 pm next Wednesday, January 14 Review math essential

### CS 103X: Discrete Structures Homework Assignment 3 Solutions

CS 103X: Discrete Structures Homework Assignment 3 s Exercise 1 (20 points). On well-ordering and induction: (a) Prove the induction principle from the well-ordering principle. (b) Prove the well-ordering

### 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

### Today s Outline. Exercise. Binary Search Analysis. Linear Search Analysis. Asymptotic Analysis. Analyzing Code. Announcements. Asymptotic Analysis

Today s Outline Announcements Assignment #1 due Thurs, Oct 7 at 11:45pm Asymptotic Analysis Asymptotic Analysis CSE 7 Data Structures & Algorithms Ruth Anderson Autumn 2010 Exercise Analyzing Code bool

### 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

### 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

### 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 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

### Class Overview. CSE 326: Data Structures. Goals. Goals. Data Structures. Goals. Introduction

Class Overview CSE 326: Data Structures Introduction Introduction to many of the basic data structures used in computer software Understand the data structures Analyze the algorithms that use them Know

### CSC 180 H1F Algorithm Runtime Analysis Lecture Notes Fall 2015

1 Introduction These notes introduce basic runtime analysis of algorithms. We would like to be able to tell if a given algorithm is time-efficient, and to be able to compare different algorithms. 2 Linear

### 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)

### Math 55: Discrete Mathematics

Math 55: Discrete Mathematics UC Berkeley, Fall 2011 Homework # 5, due Wednesday, February 22 5.1.4 Let P (n) be the statement that 1 3 + 2 3 + + n 3 = (n(n + 1)/2) 2 for the positive integer n. a) What

### 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.

### Lecture 3: Finding integer solutions to systems of linear equations

Lecture 3: Finding integer solutions to systems of linear equations Algorithmic Number Theory (Fall 2014) Rutgers University Swastik Kopparty Scribe: Abhishek Bhrushundi 1 Overview The goal of this lecture

### 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

### Data Structures. Algorithm Performance and Big O Analysis

Data Structures Algorithm Performance and Big O Analysis What s an Algorithm? a clearly specified set of instructions to be followed to solve a problem. In essence: A computer program. In detail: Defined

### Chapter 3. if 2 a i then location: = i. Page 40

Chapter 3 1. Describe an algorithm that takes a list of n integers a 1,a 2,,a n and finds the number of integers each greater than five in the list. Ans: procedure greaterthanfive(a 1,,a n : integers)

### The Prime Numbers. Definition. A prime number is a positive integer with exactly two positive divisors.

The Prime Numbers Before starting our study of primes, we record the following important lemma. Recall that integers a, b are said to be relatively prime if gcd(a, b) = 1. Lemma (Euclid s Lemma). If gcd(a,

### 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

### Lecture Notes on Linear Search

Lecture Notes on Linear Search 15-122: Principles of Imperative Computation Frank Pfenning Lecture 5 January 29, 2013 1 Introduction One of the fundamental and recurring problems in computer science is

### Recursive Algorithms. Recursion. Motivating Example Factorial Recall the factorial function. { 1 if n = 1 n! = n (n 1)! if n > 1

Recursion Slides by Christopher M Bourke Instructor: Berthe Y Choueiry Fall 007 Computer Science & Engineering 35 Introduction to Discrete Mathematics Sections 71-7 of Rosen cse35@cseunledu Recursive Algorithms

### Iteration, Induction, and Recursion

CHAPTER 2 Iteration, Induction, and Recursion The power of computers comes from their ability to execute the same task, or different versions of the same task, repeatedly. In computing, the theme of iteration

### Computer Science 210: Data Structures. Searching

Computer Science 210: Data Structures Searching Searching Given a sequence of elements, and a target element, find whether the target occurs in the sequence Variations: find first occurence; find all occurences

### 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

### Sample Induction Proofs

Math 3 Worksheet: Induction Proofs III, Sample Proofs A.J. Hildebrand Sample Induction Proofs Below are model solutions to some of the practice problems on the induction worksheets. The solutions given

### 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

### 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 >

### Mathematical Induction. Lecture 10-11

Mathematical Induction Lecture 10-11 Menu Mathematical Induction Strong Induction Recursive Definitions Structural Induction Climbing an Infinite Ladder Suppose we have an infinite ladder: 1. We can reach

### Loop Invariants and Binary Search

Loop Invariants and Binary Search Chapter 4.3.3 and 9.3.1-1 - Outline Ø Iterative Algorithms, Assertions and Proofs of Correctness Ø Binary Search: A Case Study - 2 - Outline Ø Iterative Algorithms, Assertions

### WRITING PROOFS. Christopher Heil Georgia Institute of Technology

WRITING PROOFS Christopher Heil Georgia Institute of Technology A theorem is just a statement of fact A proof of the theorem is a logical explanation of why the theorem is true Many theorems have this

### Math 55: Discrete Mathematics

Math 55: Discrete Mathematics UC Berkeley, Spring 2012 Homework # 9, due Wednesday, April 11 8.1.5 How many ways are there to pay a bill of 17 pesos using a currency with coins of values of 1 peso, 2 pesos,

### Theory of Computation Prof. Kamala Krithivasan Department of Computer Science and Engineering Indian Institute of Technology, Madras

Theory of Computation Prof. Kamala Krithivasan Department of Computer Science and Engineering Indian Institute of Technology, Madras Lecture No. # 31 Recursive Sets, Recursively Innumerable Sets, Encoding

### Sequential Data Structures

Sequential Data Structures In this lecture we introduce the basic data structures for storing sequences of objects. These data structures are based on arrays and linked lists, which you met in first year

### 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.

### 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

### 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

### Homework until Test #2

MATH31: Number Theory Homework until Test # Philipp BRAUN Section 3.1 page 43, 1. It has been conjectured that there are infinitely many primes of the form n. Exhibit five such primes. Solution. Five such

### APPLICATIONS OF THE ORDER FUNCTION

APPLICATIONS OF THE ORDER FUNCTION LECTURE NOTES: MATH 432, CSUSM, SPRING 2009. PROF. WAYNE AITKEN In this lecture we will explore several applications of order functions including formulas for GCDs and

### The Running Time of Programs

CHAPTER 3 The Running Time of Programs In Chapter 2, we saw two radically different algorithms for sorting: selection sort and merge sort. There are, in fact, scores of algorithms for sorting. This situation

### 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

### CSE 5311 Homework 3 Solution

CSE 5311 Homework 3 Solution Problem 15.1-1 Show that equation (15.4) follows from equation (15.3) and the initial condition T (0) = 1. We can verify that T (n) = n is a solution to the given recurrence

### Basic Proof Techniques

Basic Proof Techniques David Ferry dsf43@truman.edu September 13, 010 1 Four Fundamental Proof Techniques When one wishes to prove the statement P Q there are four fundamental approaches. This document

### SECTION 10-2 Mathematical Induction

73 0 Sequences and Series 6. Approximate e 0. using the first five terms of the series. Compare this approximation with your calculator evaluation of e 0.. 6. Approximate e 0.5 using the first five terms

### 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

### In mathematics, it is often important to get a handle on the error term of an approximation. For instance, people will write

Big O notation (with a capital letter O, not a zero), also called Landau's symbol, is a symbolism used in complexity theory, computer science, and mathematics to describe the asymptotic behavior of functions.

### k, then n = p2α 1 1 pα k

Powers of Integers An integer n is a perfect square if n = m for some integer m. Taking into account the prime factorization, if m = p α 1 1 pα k k, then n = pα 1 1 p α k k. That is, n is a perfect square

### CSE 135: Introduction to Theory of Computation Decidability and Recognizability

CSE 135: Introduction to Theory of Computation Decidability and Recognizability Sungjin Im University of California, Merced 04-28, 30-2014 High-Level Descriptions of Computation Instead of giving a Turing

### 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

### 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

### 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

### Homework 5 Solutions

Homework 5 Solutions 4.2: 2: a. 321 = 256 + 64 + 1 = (01000001) 2 b. 1023 = 512 + 256 + 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = (1111111111) 2. Note that this is 1 less than the next power of 2, 1024, 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

### Regular Languages and Finite Automata

Regular Languages and Finite Automata 1 Introduction Hing Leung Department of Computer Science New Mexico State University Sep 16, 2010 In 1943, McCulloch and Pitts [4] published a pioneering work on a

### 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

### 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

### Analysis of a Search Algorithm

CSE 326 Lecture 4: Lists and Stacks 1. Agfgd 2. Dgsdsfd 3. Hdffdsf 4. Sdfgsfdg 5. Tefsdgass We will review: Analysis: Searching a sorted array (from last time) List ADT: Insert, Delete, Find, First, Kth,

### Section 6-2 Mathematical Induction

6- Mathematical Induction 457 In calculus, it can be shown that e x k0 x k k! x x x3!! 3!... xn n! where the larger n is, the better the approximation. Problems 6 and 6 refer to this series. Note that

### A simple algorithm with no simple verication

A simple algorithm with no simple verication Laszlo Csirmaz Central European University Abstract The correctness of a simple sorting algorithm is resented, which algorithm is \evidently wrong" at the rst

### 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

### 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

### Chapter 3. Cartesian Products and Relations. 3.1 Cartesian Products

Chapter 3 Cartesian Products and Relations The material in this chapter is the first real encounter with abstraction. Relations are very general thing they are a special type of subset. After introducing

### Discrete Mathematics: Homework 7 solution. Due: 2011.6.03

EE 2060 Discrete Mathematics spring 2011 Discrete Mathematics: Homework 7 solution Due: 2011.6.03 1. Let a n = 2 n + 5 3 n for n = 0, 1, 2,... (a) (2%) Find a 0, a 1, a 2, a 3 and a 4. (b) (2%) Show that

### TAKE-AWAY GAMES. ALLEN J. SCHWENK California Institute of Technology, Pasadena, California INTRODUCTION

TAKE-AWAY GAMES ALLEN J. SCHWENK California Institute of Technology, Pasadena, California L INTRODUCTION Several games of Tf take-away?f have become popular. The purpose of this paper is to determine the

### 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

### Notes on counting finite sets

Notes on counting finite sets Murray Eisenberg February 26, 2009 Contents 0 Introduction 2 1 What is a finite set? 2 2 Counting unions and cartesian products 4 2.1 Sum rules......................................

### Divide and Conquer: Counting Inversions

Divide and Conquer: Counting Inversions Rank Analysis Collaborative filtering matches your preference (books, music, movies, restaurants) with that of others finds people with similar tastes recommends

### Mathematical Induction

Mathematical Induction (Handout March 8, 01) The Principle of Mathematical Induction provides a means to prove infinitely many statements all at once The principle is logical rather than strictly mathematical,

### 10.3 POWER METHOD FOR APPROXIMATING EIGENVALUES

58 CHAPTER NUMERICAL METHODS. POWER METHOD FOR APPROXIMATING EIGENVALUES In Chapter 7 you saw that the eigenvalues of an n n matrix A are obtained by solving its characteristic equation n c nn c nn...

### Worksheet on induction Calculus I Fall 2006 First, let us explain the use of for summation. The notation

Worksheet on induction MA113 Calculus I Fall 2006 First, let us explain the use of for summation. The notation f(k) means to evaluate the function f(k) at k = 1, 2,..., n and add up the results. In other

### UNIT 5C Merge Sort. Course Announcements

UNIT 5C Merge Sort 1 Course Announcements Exam rooms for Lecture 1, 2:30 3:20 Sections A, B, C, D at Rashid Sections E, F, G at Baker A51 (Giant Eagle Auditorium) Exam rooms for Lecture 2, 3:30 4:20 Sections

### Dynamic Programming Problem Set Partial Solution CMPSC 465

Dynamic Programming Problem Set Partial Solution CMPSC 465 I ve annotated this document with partial solutions to problems written more like a test solution. (I remind you again, though, that a formal

### Arkansas Tech University MATH 4033: Elementary Modern Algebra Dr. Marcel B. Finan

Arkansas Tech University MATH 4033: Elementary Modern Algebra Dr. Marcel B. Finan 3 Binary Operations We are used to addition and multiplication of real numbers. These operations combine two real numbers

### THE DIMENSION OF A VECTOR SPACE

THE DIMENSION OF A VECTOR SPACE KEITH CONRAD This handout is a supplementary discussion leading up to the definition of dimension and some of its basic properties. Let V be a vector space over a field

### Homework Exam 1, Geometric Algorithms, 2016

Homework Exam 1, Geometric Algorithms, 2016 1. (3 points) Let P be a convex polyhedron in 3-dimensional space. The boundary of P is represented as a DCEL, storing the incidence relationships between the

### Discrete Mathematics: Solutions to Homework (12%) For each of the following sets, determine whether {2} is an element of that set.

Discrete Mathematics: Solutions to Homework 2 1. (12%) For each of the following sets, determine whether {2} is an element of that set. (a) {x R x is an integer greater than 1} (b) {x R x is the square

### Functions Recursion. C++ functions. Declare/prototype. Define. Call. int myfunction (int ); int myfunction (int x){ int y = x*x; return y; }

Functions Recursion C++ functions Declare/prototype int myfunction (int ); Define int myfunction (int x){ int y = x*x; return y; Call int a; a = myfunction (7); function call flow types type of function

### Binary search algorithm

Binary search algorithm Definition Search a sorted array by repeatedly dividing the search interval in half. Begin with an interval covering the whole array. If the value of the search key is less than

### Notes on Complexity Theory Last updated: August, 2011. Lecture 1

Notes on Complexity Theory Last updated: August, 2011 Jonathan Katz Lecture 1 1 Turing Machines I assume that most students have encountered Turing machines before. (Students who have not may want to look

### Quiz 1 Solutions. (a) T F The height of any binary search tree with n nodes is O(log n). Explain:

Introduction to Algorithms March 9, 2011 Massachusetts Institute of Technology 6.006 Spring 2011 Professors Erik Demaine, Piotr Indyk, and Manolis Kellis Quiz 1 Solutions Problem 1. Quiz 1 Solutions True

### CS2 Algorithms and Data Structures Note 11. Breadth-First Search and Shortest Paths

CS2 Algorithms and Data Structures Note 11 Breadth-First Search and Shortest Paths In this last lecture of the CS2 Algorithms and Data Structures thread we will consider the problem of computing distances

### Chapter 3. Distribution Problems. 3.1 The idea of a distribution. 3.1.1 The twenty-fold way

Chapter 3 Distribution Problems 3.1 The idea of a distribution Many of the problems we solved in Chapter 1 may be thought of as problems of distributing objects (such as pieces of fruit or ping-pong balls)

### Emcient Evaluation of Polynomial Forms*

JOURNAL OF COMPUTER AND SYSTEM SCIENCES 6, 625--638 (1972) Emcient Evaluation of Polynomial Forms* I~ MUNRO Department of Applied Analysis and Computer Science, University of Waterloo, Waterloo, Ontario,

### 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

### HOMEWORK 5 SOLUTIONS. n!f n (1) lim. ln x n! + xn x. 1 = G n 1 (x). (2) k + 1 n. (n 1)!

Math 7 Fall 205 HOMEWORK 5 SOLUTIONS Problem. 2008 B2 Let F 0 x = ln x. For n 0 and x > 0, let F n+ x = 0 F ntdt. Evaluate n!f n lim n ln n. By directly computing F n x for small n s, we obtain the following

### 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

### it is easy to see that α = a

21. Polynomial rings Let us now turn out attention to determining the prime elements of a polynomial ring, where the coefficient ring is a field. We already know that such a polynomial ring is a UF. Therefore

### ON THE COMPLEXITY OF THE GAME OF SET. {kamalika,pbg,dratajcz,hoeteck}@cs.berkeley.edu

ON THE COMPLEXITY OF THE GAME OF SET KAMALIKA CHAUDHURI, BRIGHTEN GODFREY, DAVID RATAJCZAK, AND HOETECK WEE {kamalika,pbg,dratajcz,hoeteck}@cs.berkeley.edu ABSTRACT. Set R is a card game played with a