Assignment 1. Stefano Guerra. October 11, The following observation follows directly from the definition of in order and pre order traversal:

Save this PDF as:

Size: px
Start display at page:

Download "Assignment 1. Stefano Guerra. October 11, The following observation follows directly from the definition of in order and pre order traversal:"

Transcription

1 Assignment 1 Stefano Guerra October 11, Problem 1 Describe a recursive algorithm to reconstruct an arbitrary binary tree, given its preorder and inorder node sequences as input. First, recall that pre order and in order are two ways of traversing a tree. (for binary trees) basic actions one can perform at a node: Both are a combination of three 1. read the information that the node contains. 2. Move to the left child. 3. Move to the right child. The difference between in order and pre order is just about the order in which these operations are performed. The in order traversal first moves to the left child, then read the content of the node, and finally moves to the right child. The pre-order traversal first read the content of the node, then moves to the left child, and finally to the right child. Each of these traversals can be recorded in an array, where the entries are the nodes of the tree, recorded in the order they are visited. Note also that both these traversals can be implemented recursively: 1. InOrder(T ) = InOrder(T L ) + [r] + InOrder(T R ) 2. PreOrder(T ) = [r] + PreOrder(T L ) + PreOrder(T R ) where r is the root of the tree T, T L (T R ) is the sub tree of T with root the left (right) child of r, and the plus sign means array concatenation. The following observation follows directly from the definition of in order and pre order traversal: a. In a pre order traversal the first node in the list is always the root node. b. The in order traversal has the nodes of the sub tree rooted at the left child of the root, appearing all before the root node. Similarly the nodes of the sub tree rooted at the right child of the root, appear after the root node. An algorithm which reconstruct a three given its in order and pre order traversals can be designed as follows: The input is given by two lists, both containing all the nodes of the tree under consideration, T. One list contains the nodes in the in order order I = I[1, 2,..., n], the other in pre order order P = P [1, 2,..., n]. Here n is the number of nodes in the tree we want to reconstruct. Note also that we can write: I = I(T ) = InOrder(T L ) + [r] + InOrder(T R ) and P = P (T ) = [r] + PreOrder(T L ) + PreOrder(T R ). The root of the tree is the first entry in P. Let k be the position of P [1], in the list I. 1

2 Recursively reconstruct the left and right sub trees linked to the root node by passing as input of the algorithm the following two pairs of lists: the left sub tree will be reconstructed on the input I L = I[1, 2,..., k 1], P L, and the right sub tree on the input I R = I[k + 1, k + 2,..., n], P R. The list P L (P R ) is the sublist of P which contains the nodes appearing in I L (I R ). Alternatively we can write: I L = InOrder(T L ), I R = InOrder(T R ), P L = PreOrder(T L ), and P R = PreOrder(T R ). Finally the base case, if the input to the algorithm consists in a pair of empty lists, then the output is the empty tree. Let s give an example to clarify how the construction goes. Consider the following binary tree: A B F C E G D H I Then its in order array is I = [D, C, B, E, A, H, G, I, F ], and its pre order array is P = [A, B, C, D, E, F, G, H, I]. Since the first node in the pre order list is A, this means that A is the root node. Then we look in the in order list I and define I L = [D, C, B, E], these are the nodes in the three which belong to the sub-tree with root the left child of A. Similarly I R = [H, G, I, F ] contains the nodes of the sub tree rooted at the right child of A. Finally define P L = [B, C, D, E] (P R = [F, G, H, I]), since this is the sub list of P containing the nodes in I L (I R ). The pairs (I L, P L ) and (I R, P R ) are passed as input to the algorithm to reconstruct the sub trees rooted at the left and right child of A. It is not clear to me if a proof of correctness should be provided or not. In any case here it is. The proof proceeds by induction on the number of elements in the lists 1. As base case we consider inputs of length one. In this case the tree consists only in the root node and there is nothing to show. One can also consider the base case to be given by two empty lists, in which case the algorithm returns the empty tree. Again there is nothing to be checked. Now assume that the algorithm is correct for input lists of length at most n 1, we want to show that the algorithm is correct for input lists of length n. The algorithm picks as root of the tree the first entry of P. As noted above this is always the root of the tree. Then the input to the recursive call are (I L, P L ) and (I R, P R ). These lists are all of length at most n 1, since the root of the original tree has been removed. By the observation above, the list I L (I R ) contains the nodes of the sub tree rooted at the left (right) child of the root tree, therefore by induction hypothesis the algorithm correctly reconstructs this tree. It is also not clear if we have to analyze the running time, hopefully if something is wrong in my argument, and this is not required for the solution, no points will be deducted. If the tree T has all log(n) levels full, then since at each level O(n) work is done (we have to search the list I for the root node), then the running time is O(n log(n)). If the tree T has n levels, i.e it is a linked list, then the running time is O(n 2 ): there are n levels and at each level we still have to search for the root node in I, which has O(n) elements. 1 Note that we assume that the lists provided as input to the algorithm are legitimate lists, i.e. they have the same length, they contains the same items, and that no element in I R appears in P before all the elements of I L have been listed (in P ). 2

3 2 Problem 2 Suppose you are given two sets of n points, one set {p 1, p 2,..., p n } on the line y = 0 and the other set {q 1, q 2,..., q n } on the line y = 1. Create a set of n line segments by connecting each point p i to the corresponding point q i. Suppose no three line segments intersect in a point. Describe an algorithm to determine how many pairs of these line segments intersect. Prove that your algorithm is correct, and analyze its running time. For full credit your algorithm should work in O(n log(n)) time. A correct O(n 2 ) time algorithm receives 10 points. First note that it is not important that the points are on the lines y = 0 and y = 1, what matters is the label associated to each point. To start with we assume that the labels of the points p i are in ascending order, i.e. the label of p i is i. This allows us to think of the set of points q i as a permutation of the integers {1, 2,..., n}. We can also assume that the input of the algorithm is an array with entries being in the set {1, 2,..., n}, arranged in the same order as the labels of the q s, i.e. it is a permutation of the set {1, 2,..., n}. From now on when we say permutation we mean permutation on {1, 2,..., n}. Finally we have to say what the intersecting lines in the problem correspond to in terms of permutations. Given a permutation σ, an inversion is given by a pair of integer i, j {1, 2,..., n}, i < j, such that σ(i) > σ(j). A simple observation is that if i and j form an inversion for the permutation defined by the q s, then the lines p i q i, p j q j intersect. Therefore the problem of counting the number of intersection points between pairs of lines reduces to the problem of counting inversion in the permutation defined by the q s. In general one can define an inversion in an array of numbers: two indexes i < j form an inversion if A[i] > A[j]. Here is an algorithm to compute the number of inversions in an array A[1, 2,..., n]: InversionCount(A[1, 2,..., n]): if n == 1: return 0 m n 2 (i 1, L) InversionCount(A[1, 2,..., m]) (i 2, M) InversionCount(A[m + 1, m + 2,..., n]) (i 3, N) MergeCount(L, M) return (i 1 + i 2 + i 3, N) MergeCount(L, M) merges and sorts the arrays L and M, and counts the number of inversions between elements of L and elements of M. The merge and sort part is done as in merge sort. In addition for each element a in L one checks how many elements in M are smaller than a. Each of this generates an inversion. Since one has to check all elements in L for inversions, which takes linear time, the search in M can be done either with linear search or binary search. The merging part of the algorithm takes also linear time as we saw in class. In total the whole algorithm s running time is the same as merge sort, O(n log(n)): the recursion tree has O(log(n)) levels and at each level O(n) work is done. 3

4 3 Problem 3 Design an algorithm that given an array of integers A[1..n] (that contains at least one positive integer), computes max 1 i j n k=i j A[k] For example, if A = [31, 41, 59,26, 53,58,97, 93, 23, 84], the output must be 187. Prove that your algorithm is correct, and analyze its running time. For full credit your algorithm should work in linear time. For any credit (more than I dont know ) you algorithm should work in O(n 2 ) time. A linear algorithm which computes the maximum of the summation over sub-arrays of A[1,..., n] can be designed as follows: 1. Define two variables max and sum and set them equal to zero. These two variables depend on the index i {1, 2,..., n}. 2. Loop over the entries of A, at step i we start with max[i 1] and sum[i 1]. Then we update both variables as follows: (a) sum[i] = max{0, sum[i 1] + A[i]}. This is the maximum for the sum of consecutive elements of A which ends at A[i]. (b) max[i] = max{max[i 1], sum[i]} 3. The algorithm returns max[n]. Correctness of the algorithm: This can be done by induction on the length of the input array. If the input array has length one, then A[1] is positive, since at least one entry is positive by hypothesis, and so sum = max = A[1]. There is nothing to proof in this case. Now, assume that the algorithm returns the correct answer for input arrays of length at most n 1, we want to show that the algorithm is correct also on arrays of length n. By induction hypothesis we know that sum[n 1] is the maximum of the sums of consecutive elements of A[1, 2,..., n 1] ending at A[n 1], while max[n 1] is the maximum value for partial sums of consecutive elements in A[1, 2..., n 1]. Now, if A[n] is positive, sum[n] = sum[n 1]+A[n], and max[n] = max{max[n 1], sum[n]}, which will return the maximum for partial sums of consecutive elements in A. If A[n] is negative, or zero, then sum[n] cannot be bigger than sum[n 1], and so max[n] = max[n 1]. Then the induction hypothesis tells us that we already have the right answer (since the sub array we are looking for is contained in A[1, 2,..., n 1]). Running time: This algorithm runs in O(n) time since it considers each element of the array once and at each step it performs a sum, two comparisons and possibly two variables update, and all these are constant time operations. Source: wikipedia. 4

5 4 Problem 4 A palindrome is any string that is exactly the same as its reversal, like I, or DEED, or RACECAR, or AMANA- PLANACATACANALPANAMA. Describe an algorithm to find the length of the longest subsequence of a given string that is also a palindrome. For example, the longest palindrome subsequence of MAHDYNAMICPROGRAM- ZLETMESHOWYOUTHEM is MHYMRORMYHM, so given that string as input, your algorithm should output the number 11. Prove that your algorithm is correct, and analyze its running time. We are going to think of a string as an array of characters, therefore the input of our algorithm is an array A[1, 2,..., n]. The output is a sub string of A[1, 2,..., n] which is the longest palindrome sub string contained in A[1, 2,..., n]. If we are interested just in the length of the longest palindrome contained in A[1, 2,..., n] we can modify the algorithm below to return the length of the longest palindrome instead of the string itself. Then the solution is given by a recursive algorithm: LongestPalindrome(A[1, 2,..., n]): if n == 0: return empty string else if n == 1: return A[1] if A[1] == A[n]: return A[1] + LongestPalindrome(A[2, 3,... n 1]) + A[n] return max{ LongestPalindrome(A[1, 2,..., n 1]), LongestPalindrome(A[2, 3,..., n]) } The algorithm returns the empty string if the input is empty, and the input string if this has only one character (since a single character is a particular instance of a palindrome). If the input string has more than one character the algorithm compares the first and the last character, if they are the same then it looks recursively for the longest palindrome in the sub string of A obtained from A by removing the first and the last character. It returns the string found by the recursive call to which are attached the first character, at the beginning, and the last character, at the end. If the first and the last character are not equal, then it looks recursively for the longest palindrome in the sub strings A[1, 2,..., n 1] and A[2, 3,..., n], and returns the longest between the two. Correctness of the algorithm: the correctness of the algorithm can be proved by induction on the length of the input string. If the input has length one, than the algorithm returns the input string itself, which is the longest palindrome sub string. Next, assume that the algorithm is correct for input strings of length at most n 1, we want to show that the algorithm is correct for input strings of length n. If the first and the last characters are not equal then, by induction hypothesis, the algorithm finds the longest sub string which is a palindrome for either strings A[1, 2,..., n 1] and A[2, 3,..., n]. By taking the longest of the two we are guaranteed to have found the longest palindrome sub string of A[1, 2,..., n] 2. If the first and the last character of the input string A[1, 2,..., n] are equal, then the induction hypothesis guarantees that the algorithm finds the longest palindrome of A[2, 3,..., n 1], and so A[1] + LongestPalindrome(A[2, 3,... n 1]) + A[n] is also a palindrome. This will be the longest palindrome sub string of A[1, 2,..., n]. In fact the only thing which can happen is that there is a palindrome sub string of A[2, 3,..., n] (or A[1, 2,..., n 1]) 3. Then, either this palindrome sub string ends with A[n] or not. If A[n] is not the last character of the longest palindrome 2 Note that we cannot make the palindrome sub string found by the algorithm for A[1, 2,..., n 1] (resp. A[2, 3,..., n]) longer by adding the last (resp. first) character, without compromising the fact that that string is palindrome. 3 We consider A[2, 3,..., n] here, the argument for A[1, 2,..., n 1] is similar with A[n] replaced by A[1] 5

6 sub string of A[2, 3,..., n], then the palindrome is actually a sub string of A[2, 3,..., n 1] and so A[1] + LongestPalindrome(A[2, 3,... n 1]) + A[n] is the longest palindrome sub string of A[1, 2,..., n]. On the other hand, if A[n] is the last character of a palindrome sub string of A[2, 3,..., n], s[1, 2,..., m], then both s[1] and s[m], will be also equal to A[n], and so s[2, 3,..., m 1] is a palindrome sub string of A[2, 3,..., n 1]. Its length will be at most the same as the length of LongestPalindrome(A[2, 3,... n 1]), by induction hypothesis. This completes the proof. Running Time: The algorithm as presented above has an exponential running time since it performs some computations several time. For example in computing the longest palindrome of A[2, 3,..., n] and A[1, 2,..., n 1], the longest palindrome of A[2, 3,..., n 1] will be computed twice. To avoid this problem, and reduce the running time, one can store the results of the new computation and look up the one for the cases already considered. If this is done, each step of the iteration takes O(n) time (the time to write the longest palindrome sub string, which is the worst case is of order n), and the running time of the algorithm is given by the time needed to fill the storage table, multiplied by the time required to write one cell of the table. In our case the storage table has O(n 2 ) elements, and so the total running time is O(n 3 ). The running time of the algorithm which computes the length of the longest palindrome sub string is O(n 2 ), since now the time which takes to fill a cell of the table is constant (the time to write a number). For completeness here is the algorithm which returns the length of the longest palindrome sub string instead of the string itself: LongestPalindromeLen(A[1, 2,..., n]): if n == 0: return 0 else if n == 1: return 1 if A[1] == A[n]: return LongestPalindromeLen(A[2, 3,... n 1]) + 2 return max{ LongestPalindromeLen(A[1, 2,..., n 1]), LongestPalindromeLen(A[2, 3,..., n]) } 6

Searching Algorithms/Time Analysis

Searching Algorithms/Time Analysis CSE21 Fall 2017, Day 8 Oct 16, 2017 https://sites.google.com/a/eng.ucsd.edu/cse21-fall-2017-miles-jones/ (MinSort) loop invariant induction Loop invariant: After the

Data Structure and Algorithm Midterm Reference Solution TA

Data Structure and Algorithm Midterm Reference Solution TA email: dsa1@csie.ntu.edu.tw Problem 1. To prove log 2 n! = Θ(n log n), it suffices to show N N, c 1, c 2 > 0 such that c 1 n ln n ln n! c 2 n

1 Dynamic Programming

Recitation 13 Dynamic Programming Parallel and Sequential Data Structures and Algorithms, 15-210 (Spring 2013) April 17, 2013 1 Dynamic Programming Dynamic programming is a technique to avoid needless

Sorting and Selection

Sorting and Selection Introduction Divide and Conquer Merge-Sort Quick-Sort Radix-Sort Bucket-Sort 10-1 Introduction Assuming we have a sequence S storing a list of keyelement entries. The key of the element

Recitation 9. Prelim Review

Recitation 9 Prelim Review 1 Heaps 2 Review: Binary heap min heap 1 2 99 4 3 PriorityQueue Maintains max or min of collection (no duplicates) Follows heap order invariant at every level Always balanced!

Recursive Definitions Structural Induction Recursive Algorithms

Chapter 4 1 4.3-4.4 Recursive Definitions Structural Induction Recursive Algorithms 2 Section 4.1 3 Principle of Mathematical Induction Principle of Mathematical Induction: To prove that P(n) is true for

Second Examination Solution

University of Illinois at Urbana-Champaign Department of Computer Science Second Examination Solution CS 225 Data Structures and Software Principles Fall 2007 7p-9p, Thursday, November 8 Name: NetID: Lab

WYSE Academic Challenge State Finals Computer Science 2007 Solution Set

WYSE Academic Challenge State Finals Computer Science 2007 Solution Set 1. Correct answer: C. a) PGP is for encrypting documents, traditionally used for email. b) SSH is used to gain secure access to a

Figure 4.1: The evolution of a rooted tree.

106 CHAPTER 4. INDUCTION, RECURSION AND RECURRENCES 4.6 Rooted Trees 4.6.1 The idea of a rooted tree We talked about how a tree diagram helps us visualize merge sort or other divide and conquer algorithms.

Data Structures and Algorithms Dr. Naveen Garg Department of Computer Science and Engineering Indian Institute of Technology, Delhi.

Data Structures and Algorithms Dr. Naveen Garg Department of Computer Science and Engineering Indian Institute of Technology, Delhi Lecture 18 Tries Today we are going to be talking about another data

Recall our recursive multiply algorithm:

Recall our recursive multiply algorithm: PRECONDITION: x and y are both binary bit arrays of length n, n a power of 2. POSTCONDITION: Returns a binary bit array equal to the product of x and y. REC MULTIPLY

TREES. Trees - Introduction

TREES Chapter 6 Trees - Introduction All previous data organizations we've studied are linear each element can have only one predecessor and successor Accessing all elements in a linear sequence is O(n)

Recursion defining an object (or function, algorithm, etc.) in terms of itself. Recursion can be used to define sequences

Section 5.3 1 Recursion 2 Recursion Recursion defining an object (or function, algorithm, etc.) in terms of itself. Recursion can be used to define sequences Previously sequences were defined using a specific

CS134 Spring 2005 Final Exam Mon. June. 20, 2005 Signature: Question # Out Of Marks Marker Total

CS134 Spring 2005 Final Exam Mon. June. 20, 2005 Please check your tutorial (TUT) section from the list below: TUT 101: F 11:30, MC 4042 TUT 102: M 10:30, MC 4042 TUT 103: M 11:30, MC 4058 TUT 104: F 10:30,

Fundamental mathematical techniques reviewed: Mathematical induction Recursion. Typically taught in courses such as Calculus and Discrete Mathematics.

Fundamental mathematical techniques reviewed: Mathematical induction Recursion Typically taught in courses such as Calculus and Discrete Mathematics. Techniques introduced: Divide-and-Conquer Algorithms

CSC 505, Spring 2005 Week 6 Lectures page 1 of 9

CSC 505, Spring 2005 Week 6 Lectures page 1 of 9 Objectives: learn general strategies for problems about order statistics learn how to find the median (or k-th largest) in linear average-case number of

(D) There is a constant value n 0 1 such that B is faster than A for every input of size. n n 0.

Part : Multiple Choice Enter your answers on the Scantron sheet. We will not mark answers that have been entered on this sheet. Each multiple choice question is worth. marks. Note. when you are asked to

INF2220: algorithms and data structures Series 1

Universitetet i Oslo Institutt for Informatikk A. Maus, R.K. Runde, I. Yu INF2220: algorithms and data structures Series 1 Topic Trees & estimation of running time (Exercises with hints for solution) Issued:

Lecture Notes on Binary Search Trees

Lecture Notes on Binary Search Trees 15-122: Principles of Imperative Computation Tom Cortina Lecture 15 October 14, 2010 1 Introduction In the previous two lectures we have seen how to exploit the structure

Design and Analysis of Algorithms

Design and Analysis of Algorithms CSE 5311 Lecture 8 Sorting in Linear Time Junzhou Huang, Ph.D. Department of Computer Science and Engineering CSE5311 Design and Analysis of Algorithms 1 Sorting So Far

Q1 Q2 Q3 Q4 Q5 Q6 Total

Name: SSN: Computer Science Foundation Exam May 5, 006 Computer Science Section 1A Q1 Q Q3 Q4 Q5 Q6 Total KNW KNW KNW ANL,DSN KNW DSN You have to do all the 6 problems in this section of the exam. Partial

n 1 x i = xn 1 x 1. i= (2n 1) = n 2.

Questions 1. Use mathematical induction to prove that, for any n 1 n 1 x i = xn 1 x 1. (Recall that I proved it in a different way back in lecture 2.) 2. Use mathematical induction to prove that, for all

CSE 2123 Recursion. Jeremy Morris

CSE 2123 Recursion Jeremy Morris 1 Past Few Weeks For the past few weeks we have been focusing on data structures Classes & Object-oriented programming Collections Lists, Sets, Maps, etc. Now we turn our

Lecture 8: The Traveling Salesman Problem

Lecture 8: The Traveling Salesman Problem Let G = (V, E) be an undirected graph. A Hamiltonian cycle of G is a cycle that visits every vertex v V exactly once. Instead of Hamiltonian cycle, we sometimes

Chapter 3 - Graphs Undirected Graphs Undirected graph. G = (V, E) V = nodes. E = edges between pairs of nodes. Captures pairwise relationship between objects. Graph size parameters: n = V, m = E. Directed

Solutions. Suppose we insert all elements of U into the table, and let n(b) be the number of elements of U that hash to bucket b. Then.

Assignment 3 1. Exercise [11.2-3 on p. 229] Modify hashing by chaining (i.e., bucketvector with BucketType = List) so that BucketType = OrderedList. How is the runtime of search, insert, and remove affected?

12/5/17. trees. CS 220: Discrete Structures and their Applications. Trees Chapter 11 in zybooks. rooted trees. rooted trees

trees CS 220: Discrete Structures and their Applications A tree is an undirected graph that is connected and has no cycles. Trees Chapter 11 in zybooks rooted trees Rooted trees. Given a tree T, choose

Trees : Part 1. Section 4.1. Theory and Terminology. A Tree? A Tree? Theory and Terminology. Theory and Terminology

Trees : Part Section. () (2) Preorder, Postorder and Levelorder Traversals Definition: A tree is a connected graph with no cycles Consequences: Between any two vertices, there is exactly one unique path

CE 221 Data Structures and Algorithms

CE 221 Data Structures and Algorithms Chapter 4: Trees (Binary) Text: Read Weiss, 4.1 4.2 Izmir University of Economics 1 Preliminaries - I (Recursive) Definition: A tree is a collection of nodes. The

1 (15 points) LexicoSort

CS161 Homework 2 Due: 22 April 2016, 12 noon Submit on Gradescope Handed out: 15 April 2016 Instructions: Please answer the following questions to the best of your ability. If you are asked to show your

CMSC351 - Fall 2014, Homework #2

CMSC351 - Fall 2014, Homework #2 Due: October 8th at the start of class Name: Section: Grades depend on neatness and clarity. Write your answers with enough detail about your approach and concepts used,

Name: Lirong TAN 1. (15 pts) (a) Define what is a shortest s-t path in a weighted, connected graph G.

1. (15 pts) (a) Define what is a shortest s-t path in a weighted, connected graph G. A shortest s-t path is a path from vertex to vertex, whose sum of edge weights is minimized. (b) Give the pseudocode

Sorting. There exist sorting algorithms which have shown to be more efficient in practice.

Sorting Next to storing and retrieving data, sorting of data is one of the more common algorithmic tasks, with many different ways to perform it. Whenever we perform a web search and/or view statistics

1 Lower bound on runtime of comparison sorts

1 Lower bound on runtime of comparison sorts So far we ve looked at several sorting algorithms insertion sort, merge sort, heapsort, and quicksort. Merge sort and heapsort run in worst-case O(n log n)

Lecture 15 : Review DRAFT

CS/Math 240: Introduction to Discrete Mathematics 3/10/2011 Lecture 15 : Review Instructor: Dieter van Melkebeek Scribe: Dalibor Zelený DRAFT Today slectureservesasareviewofthematerialthatwillappearonyoursecondmidtermexam.

Algorithm efficiency can be measured in terms of: Time Space Other resources such as processors, network packets, etc.

Algorithms Analysis Algorithm efficiency can be measured in terms of: Time Space Other resources such as processors, network packets, etc. Algorithms analysis tends to focus on time: Techniques for measuring

Solution for Homework set 3

TTIC 300 and CMSC 37000 Algorithms Winter 07 Solution for Homework set 3 Question (0 points) We are given a directed graph G = (V, E), with two special vertices s and t, and non-negative integral capacities

Comparison Based Sorting Algorithms. Algorithms and Data Structures: Lower Bounds for Sorting. Comparison Based Sorting Algorithms

Comparison Based Sorting Algorithms Algorithms and Data Structures: Lower Bounds for Sorting Definition 1 A sorting algorithm is comparison based if comparisons A[i] < A[j], A[i] A[j], A[i] = A[j], A[i]

Algorithms and Data Structures: Lower Bounds for Sorting. ADS: lect 7 slide 1

Algorithms and Data Structures: Lower Bounds for Sorting ADS: lect 7 slide 1 ADS: lect 7 slide 2 Comparison Based Sorting Algorithms Definition 1 A sorting algorithm is comparison based if comparisons

Principles of Algorithm Design

Principles of Algorithm Design When you are trying to design an algorithm or a data structure, it s often hard to see how to accomplish the task. The following techniques can often be useful: 1. Experiment

These are not polished as solutions, but ought to give a correct idea of solutions that work. Note that most problems have multiple good solutions.

CSE 591 HW Sketch Sample Solutions These are not polished as solutions, but ought to give a correct idea of solutions that work. Note that most problems have multiple good solutions. Problem 1 (a) Any

1. Find f(1), f(2), f(3), and f(4) if f(n) is defined recursively by f(0) = 1 and for n = 0, 1, 2,

Exercises Exercises 1. Find f(1), f(2), f(3), and f(4) if f(n) is defined recursively by f(0) = 1 and for n = 0, 1, 2, a) f(n + 1) = f(n) + 2. b) f(n + 1) = 3f(n). c) f(n + 1) = 2f(n). d) f(n + 1) = f(n)2

Lecture 6: Sequential Sorting

15-150 Lecture 6: Sequential Sorting Lecture by Dan Licata February 2, 2012 Today s lecture is about sorting. Along the way, we ll learn about divide and conquer algorithms, the tree method, and complete

11.1 Facility Location

CS787: Advanced Algorithms Scribe: Amanda Burton, Leah Kluegel Lecturer: Shuchi Chawla Topic: Facility Location ctd., Linear Programming Date: October 8, 2007 Today we conclude the discussion of local

String Matching. Pedro Ribeiro 2016/2017 DCC/FCUP. Pedro Ribeiro (DCC/FCUP) String Matching 2016/ / 42

String Matching Pedro Ribeiro DCC/FCUP 2016/2017 Pedro Ribeiro (DCC/FCUP) String Matching 2016/2017 1 / 42 On this lecture The String Matching Problem Naive Algorithm Deterministic Finite Automata Knuth-Morris-Pratt

Exercise 1 : B-Trees [ =17pts]

CS - Fall 003 Assignment Due : Thu November 7 (written part), Tue Dec 0 (programming part) Exercise : B-Trees [+++3+=7pts] 3 0 3 3 3 0 Figure : B-Tree. Consider the B-Tree of figure.. What are the values

Undirected Graphs. V = { 1, 2, 3, 4, 5, 6, 7, 8 } E = { 1-2, 1-3, 2-3, 2-4, 2-5, 3-5, 3-7, 3-8, 4-5, 5-6 } n = 8 m = 11

Chapter 3 - Graphs Undirected Graphs Undirected graph. G = (V, E) V = nodes. E = edges between pairs of nodes. Captures pairwise relationship between objects. Graph size parameters: n = V, m = E. V = {

We assume uniform hashing (UH):

We assume uniform hashing (UH): the probe sequence of each key is equally likely to be any of the! permutations of 0,1,, 1 UH generalizes the notion of SUH that produces not just a single number, but a

Scan Primitives for GPU Computing

Scan Primitives for GPU Computing Agenda What is scan A naïve parallel scan algorithm A work-efficient parallel scan algorithm Parallel segmented scan Applications of scan Implementation on CUDA 2 Prefix

Computational Geometry

Windowing queries Windowing Windowing queries Zoom in; re-center and zoom in; select by outlining Windowing Windowing queries Windowing Windowing queries Given a set of n axis-parallel line segments, preprocess

CSCE 2014 Final Exam Spring Version A

CSCE 2014 Final Exam Spring 2017 Version A Student Name: Student UAID: Instructions: This is a two-hour exam. Students are allowed one 8.5 by 11 page of study notes. Calculators, cell phones and computers

CSCI2100B Data Structures Trees

CSCI2100B Data Structures Trees Irwin King king@cse.cuhk.edu.hk http://www.cse.cuhk.edu.hk/~king Department of Computer Science & Engineering The Chinese University of Hong Kong Introduction General Tree

Priority Queues. 1 Introduction. 2 Naïve Implementations. CSci 335 Software Design and Analysis III Chapter 6 Priority Queues. Prof.

Priority Queues 1 Introduction Many applications require a special type of queuing in which items are pushed onto the queue by order of arrival, but removed from the queue based on some other priority

would be included in is small: to be exact. Thus with probability1, the same partition n+1 n+1 would be produced regardless of whether p is in the inp

1 Introduction 1.1 Parallel Randomized Algorihtms Using Sampling A fundamental strategy used in designing ecient algorithms is divide-and-conquer, where that input data is partitioned into several subproblems

INF2220: algorithms and data structures Series 1

Universitetet i Oslo Institutt for Informatikk I. Yu, D. Karabeg INF2220: algorithms and data structures Series 1 Topic Function growth & estimation of running time, trees Issued: 24. 08. 2016 Exercise

CSE 21 Spring 2016 Homework 4 Answer Key

1 CSE 21 Spring 2016 Homework 4 Answer Key 1. In each situation, write a recurrence relation, including base case(s), that describes the recursive structure of the problem. You do not need to solve the

Algorithms for Data Science

Algorithms for Data Science CSOR W4246 Eleni Drinea Computer Science Department Columbia University Thursday, October 1, 2015 Outline 1 Recap 2 Shortest paths in graphs with non-negative edge weights (Dijkstra

Dijkstra s algorithm for shortest paths when no edges have negative weight.

Lecture 14 Graph Algorithms II 14.1 Overview In this lecture we begin with one more algorithm for the shortest path problem, Dijkstra s algorithm. We then will see how the basic approach of this algorithm

Lecture 4 Searching Arrays

Lecture 4 Searching Arrays 15-122: Principles of Imperative Computation (Spring 2018) Frank Pfenning One of the fundamental and recurring problems in computer science is to find elements in collections,

Lecture Notes on Linear Search

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

Run Times. Efficiency Issues. Run Times cont d. More on O( ) notation

Comp2711 S1 2006 Correctness Oheads 1 Efficiency Issues Comp2711 S1 2006 Correctness Oheads 2 Run Times An implementation may be correct with respect to the Specification Pre- and Post-condition, but nevertheless

Algebra of Sets (Mathematics & Logic A)

Algebra of Sets (Mathematics & Logic A) RWK/MRQ October 28, 2002 Note. These notes are adapted (with thanks) from notes given last year by my colleague Dr Martyn Quick. Please feel free to ask me (not

CS 220: Discrete Structures and their Applications. Recursive objects and structural induction in zybooks

CS 220: Discrete Structures and their Applications Recursive objects and structural induction 6.9 6.10 in zybooks Using recursion to define objects We can use recursion to define functions: The factorial

Lecture 9 March 4, 2010

6.851: Advanced Data Structures Spring 010 Dr. André Schulz Lecture 9 March 4, 010 1 Overview Last lecture we defined the Least Common Ancestor (LCA) and Range Min Query (RMQ) problems. Recall that an

MITOCW watch?v=yarwp7tntl4

MITOCW watch?v=yarwp7tntl4 The following content is provided under a Creative Commons license. Your support will help MIT OpenCourseWare continue to offer high quality, educational resources for free.

CSE 5095 Topics in Big Data Analytics Spring 2014; Homework 1 Solutions

CSE 5095 Topics in Big Data Analytics Spring 2014; Homework 1 Solutions Note: Solutions to problems 4, 5, and 6 are due to Marius Nicolae. 1. Consider the following algorithm: for i := 1 to α n log e n

3 Trees: traversal and analysis of standard search trees. Summer Term 2010

3 Trees: traversal and analysis of standard search trees Summer Term 2010 Robert Elsässer Binary Search Trees Binary trees for storing sets of keys (in the internal nodes of trees), such that the operations

Cache-Oblivious Traversals of an Array s Pairs

Cache-Oblivious Traversals of an Array s Pairs Tobias Johnson May 7, 2007 Abstract Cache-obliviousness is a concept first introduced by Frigo et al. in [1]. We follow their model and develop a cache-oblivious

Prelim 2 SOLUTION. 5:30 PM, 25 April Total Question Name Short Search/ Collections Trees Graphs

Prelim 2 SOLUTION 5:30 PM, 25 April 2017 1 2 3 4 5 6 Total Question Name Short Search/ Collections Trees Graphs answer sort stuff Max 1 26 18 15 20 20 100 Score Grader 1. Name (1 point) Write your name

CSE Data Structures and Introduction to Algorithms... In Java! Instructor: Fei Wang. Mid-Term Exam. CSE2100 DS & Algorithms 1

CSE 2100 Data Structures and Introduction to Algorithms...! In Java!! Instructor: Fei Wang! Mid-Term Exam CSE2100 DS & Algorithms 1 1. True or False (20%=2%x10)! (1) O(n) is O(n^2) (2) The height h of

1 Variations of the Traveling Salesman Problem

Stanford University CS26: Optimization Handout 3 Luca Trevisan January, 20 Lecture 3 In which we prove the equivalence of three versions of the Traveling Salesman Problem, we provide a 2-approximate algorithm,

Chapter Fourteen Bonus Lessons: Algorithms and Efficiency

: Algorithms and Efficiency The following lessons take a deeper look at Chapter 14 topics regarding algorithms, efficiency, and Big O measurements. They can be completed by AP students after Chapter 14.

CS 171: Introduction to Computer Science II. Binary Search Trees

CS 171: Introduction to Computer Science II Binary Search Trees Binary Search Trees Symbol table applications BST definitions and terminologies Search and insert Traversal Ordered operations Delete Symbol

Lecture 6: Analysis of Algorithms (CS )

Lecture 6: Analysis of Algorithms (CS583-002) Amarda Shehu October 08, 2014 1 Outline of Today s Class 2 Traversals Querying Insertion and Deletion Sorting with BSTs 3 Red-black Trees Height of a Red-black

CSC148 Week 7. Larry Zhang

CSC148 Week 7 Larry Zhang 1 Announcements Test 1 can be picked up in DH-3008 A1 due this Saturday Next week is reading week no lecture, no labs no office hours 2 Recap Last week, learned about binary trees

Algorithms and Applications

Algorithms and Applications 1 Areas done in textbook: Sorting Algorithms Numerical Algorithms Image Processing Searching and Optimization 2 Chapter 10 Sorting Algorithms - rearranging a list of numbers

Data Structure Lecture#10: Binary Trees (Chapter 5) U Kang Seoul National University

Data Structure Lecture#10: Binary Trees (Chapter 5) U Kang Seoul National University U Kang (2016) 1 In This Lecture The concept of binary tree, its terms, and its operations Full binary tree theorem Idea

- 1 - Handout #22S May 24, 2013 Practice Second Midterm Exam Solutions. CS106B Spring 2013

CS106B Spring 2013 Handout #22S May 24, 2013 Practice Second Midterm Exam Solutions Based on handouts by Eric Roberts and Jerry Cain Problem One: Reversing a Queue One way to reverse the queue is to keep

Greedy algorithms is another useful way for solving optimization problems.

Greedy Algorithms Greedy algorithms is another useful way for solving optimization problems. Optimization Problems For the given input, we are seeking solutions that must satisfy certain conditions. These

Tree: non-recursive definition. Trees, Binary Search Trees, and Heaps. Tree: recursive definition. Tree: example.

Trees, Binary Search Trees, and Heaps CS 5301 Fall 2013 Jill Seaman Tree: non-recursive definition Tree: set of nodes and directed edges - root: one node is distinguished as the root - Every node (except

We cover recursion in 150. Why do it again in 151?

Recursion We cover recursion in 150. Why do it again in 151? First, good solutions to problems are often recursive. Here is a quick way to sort a list of objects: split the list in half, recursively sort

ENGI 4892: Data Structures Assignment 2 SOLUTIONS

ENGI 4892: Data Structures Assignment 2 SOLUTIONS Due May 30 in class at 1:00 Total marks: 50 Notes: You will lose marks for giving only the final answer for any question on this assignment. Some steps

MLR Institute of Technology

MLR Institute of Technology Laxma Reddy Avenue, Dundigal, Quthbullapur (M), Hyderabad 500 043 Phone Nos: 08418 204066 / 204088, Fax : 08418 204088 TUTORIAL QUESTION BANK Course Name : DATA STRUCTURES Course

0.1 Welcome. 0.2 Insertion sort. Jessica Su (some portions copied from CLRS)

0.1 Welcome http://cs161.stanford.edu My contact info: Jessica Su, jtysu at stanford dot edu, office hours Monday 3-5 pm in Huang basement TA office hours: Monday, Tuesday, Wednesday 7-9 pm in Huang basement

Chapter 3. Set Theory. 3.1 What is a Set?

Chapter 3 Set Theory 3.1 What is a Set? A set is a well-defined collection of objects called elements or members of the set. Here, well-defined means accurately and unambiguously stated or described. Any

Computer Science Foundation Exam

Computer Science Foundation Exam August 26, 2017 Section I A DATA STRUCTURES NO books, notes, or calculators may be used, and you must work entirely on your own. Name: UCFID: NID: Question # Max Pts Category

Heaps. Heaps. A heap is a complete binary tree.

A heap is a complete binary tree. 1 A max-heap is a complete binary tree in which the value in each internal node is greater than or equal to the values in the children of that node. A min-heap is defined

Outline. Preliminaries. Binary Trees Binary Search Trees. What is Tree? Implementation of Trees using C++ Tree traversals and applications

Trees 1 Outline Preliminaries What is Tree? Implementation of Trees using C++ Tree traversals and applications Binary Trees Binary Search Trees Structure and operations Analysis 2 What is a Tree? A tree

EECS 2011M: Fundamentals of Data Structures

M: Fundamentals of Data Structures Instructor: Suprakash Datta Office : LAS 3043 Course page: http://www.eecs.yorku.ca/course/2011m Also on Moodle Note: Some slides in this lecture are adopted from James

Binary Trees. BSTs. For example: Jargon: Data Structures & Algorithms. root node. level: internal node. edge.

Binary Trees 1 A binary tree is either empty, or it consists of a node called the root together with two binary trees called the left subtree and the right subtree of the root, which are disjoint from

University of Toronto Department of Electrical and Computer Engineering. Midterm Examination. ECE 345 Algorithms and Data Structures Fall 2010

University of Toronto Department of Electrical and Computer Engineering Midterm Examination ECE 345 Algorithms and Data Structures Fall 2010 Print your name and ID number neatly in the space provided below;

Recursion. Example R1

Recursion Certain computer problems are solved by repeating the execution of one or more statements a certain number of times. So far, we have implemented the repetition of one or more statements by using

Design and Analysis of Algorithms - - Assessment

X Courses» Design and Analysis of Algorithms Week 1 Quiz 1) In the code fragment below, start and end are integer values and prime(x) is a function that returns true if x is a prime number and false otherwise.

Computing intersections in a set of line segments: the Bentley-Ottmann algorithm

Computing intersections in a set of line segments: the Bentley-Ottmann algorithm Michiel Smid October 14, 2003 1 Introduction In these notes, we introduce a powerful technique for solving geometric problems.

CSCE f(n) = Θ(g(n)), if f(n) = O(g(n)) and f(n) = Ω(g(n)).

CSCE 3110 Asymptotic Notations Let f and g be functions on real numbers. Then: f(n) = O(g(n)), if there are constants c and n 0 so that f(n) cg(n)), for n n 0. f(n) = Ω(g(n)), if there are constants c

Sorting is a problem for which we can prove a non-trivial lower bound.

Sorting The sorting problem is defined as follows: Sorting: Given a list a with n elements possessing a total order, return a list with the same elements in non-decreasing order. Remember that total order

CS 280 Problem Set 10 Solutions Due May 3, Part A

CS 280 Problem Set 10 Due May 3, 2002 Part A (1) You are given a directed graph G with 1000 vertices. There is one weakly connected component of size 800 and several other weakly connected components of

1. Suppose you are given a magic black box that somehow answers the following decision problem in polynomial time:

1. Suppose you are given a magic black box that somehow answers the following decision problem in polynomial time: Input: A CNF formula ϕ with n variables x 1, x 2,..., x n. Output: True if there is an