# (Refer Slide Time 04:53)

Save this PDF as:

Size: px
Start display at page:

## Transcription

1 Programming and Data Structure Dr.P.P.Chakraborty Department of Computer Science and Engineering Indian Institute of Technology, Kharagpur Lecture 26 Algorithm Design -1 Having made a preliminary study of data structure design, we shall now go back and study some aspects of the design of algorithms and try to make out how to really what are the basic steps which are involved in algorithm design aspects which are not purely data structure design concepts. We will just revisit some examples which we did before and we will see some of the very important issues which are related to the design of the algorithms and related to problem decomposition and how to generate a good algorithm from an initial problem or from an initial solution. We have seen before that we will use recursive definitions to define a problem and now we will see how given a recursive definition, how we could analyze it further to obtain an algorithm which does not have some of the defects of the original recursive algorithm. And later on this algorithm design and data structuring will go hand in hand to make a complete design of an algorithm, to constitute a complete design of a solution. So we will have a quick look at these aspects of algorithm design because these two aspects will be integrated for program development. Among the three, we will study three major concepts, there are three major aspects one of them we could term, we have seen this idea before balancing the split when we did finding the minimum of n numbers or sorting of n numbers. And we discussed the issue of where to split the list into two parts and how it leads to recurrence equations which are to be solved to find out the optimal split. So this is one aspect. The second aspect this is usually called balancing in classical algorithm design terminology. The second is identifying identical sub problems, you will see that when you give a recursive solution, several sub problems which are identical and you would like to solve them only once rather than solving them again and again. And the technique for identifying identical sub problems and solving them only once has got a name which you will see in textbooks, that book is called dynamic programming. It has a different meaning or different style in other aspects where you come to state machines and there you talk of dynamic programming in a slightly different sense but inherently both of them have got very very similar meanings and third which we call pruning.

2 (Refer Slide Time 04:53) In word you try to see which of, you can make choice between sub problems and choose only one of them or decide that this sub problem need not be solved to solve the original problem and here you read two types of strategies we will see, one is called the greedy approach the other is called the branch and bound. So we will see what these things mean and try and get a flavor of how algorithm design involves these three core aspects. That is now formal methodology for this but these are some intuitive ideas which can be formalized by trying out various solutions and solving then you will get very good ideas. I would not go into actual formal definition of all this because that would need more terminology. So, the first aspect we will take is balancing because we have seen this before. And to quickly recapitulate, in balancing we have given a problem and where we had split the problem into two or more parts. And in the solution, we did not choose where to split in the initial solution we will only analyze and then say where to choose. Let us see some example. Suppose we have to find the maximum of n numbers. Now to find the maximum of n numbers, given a list L what was our recursive solution? If the size of L was 1 then obviously the problem is the base condition otherwise you split into two nonempty sets L 1 and L 2 all right and then solve these two recursively and after you solve these two recursively, you get m 1 and m 2, m 1 from L 1 and m 2 from L 2 and then you compare these two and get the final solution. So where will we split? We will be splitting in the middle, we will split left, we will split right, so to answer that question we saw that you have to solve recurrence equations. For example here the recurrence equation is related to the number of comparisons that have to be made because here the number of comparisons for n numbers is equal to 0 when n is equal to 1 and is equal to the number of comparisons in the first split list plus the number of comparisons in the second split list plus 1 when n is greater than 1, all right.

3 So this was how we solved the problem and if you open up this you will see that this will come to, you replace T (i) T (k) is equal to k minus 1 and you will see that the recurrence is solved. T (k) is equal to k minus 1, the solution to this what ever be n 1 n 2 will be k minus 1 because we replace this, this will be n minus 1 n 1 minus 1, this will be (n 2 minus 1) plus 1, this will come to n 1 plus n 2 minus 1 and we know n 1 plus n 2 is equal to n because you have split n into n 1 and n 2, so n 1 this will be n minus 1. So what does this reveal to us? (Refer Slide Time 09:03) This reveals to us that whichever way we split, whatever of the values of n 1 and n 2, you are going to require n minus 1 comparison. So you can split it in anyway you like and the algorithm will be correct. So the choice is now clear you can choose anything you want, you split 1, n minus 1, 2 n minus 2 or what ever and therefore the problem can be easily solved and it will be optimally solved all of them are optimal. So, now we are left, suppose we make a choice and we make 1 n minus 1, now the next step is what have we chosen for representing L. So we have balanced the problem optimally and we have chosen 1 n minus 1. So now we are left to choose the data structure for L. Till now L is a set. So what are the operations on L now? If it is 1 n minus 1, it is removed the front of the list, so head and the rest of the list. So if you remove the front of the list, you will get two parts. So now suppose we are given L and you read in the element, first you read in the number of elements and then so you can use an array to solve this problem without any difficulty or even if you use a linked list to solve the problem also there is no problem, there is no difficulty. So using an array or a linked list for this set L and choosing the first and rest, the problem can be solved optimally. So this is using a very very simple problem, I have shown you how you split the problem, how you have chosen the data structures for l and that s all. You can now finalized the complete all right. Any questions?

4 Let s take another problem sorting. And here in the merge sort style, we saw that when L is equal to 1 the problem is solved, otherwise again you split into L 1 and L 2 which are non-empty. You recursively solve these two to get L 1 dash and L 2 dash and then you merge these two by a merge algorithm. And we saw the recurrence equation which crops up in this situation is T (n) is equal to T(n 1 ) plus T(n 2 ) plus some k n 1 because the merge algorithm is linear time, we know that merge algorithm can be done in n comparisons when there are n elements. So you can choose any constant into n, this is what it will take and T(1) is equal to 0 and we saw that if you take one n 1 equal to 1 and n 2 is equal to n minus 1 then this will lead to order n square. On the other hand if you take n 1 is equal to n by 2 and n 2 is equal to n by 2, you will get order n log n. So you have decided to split in the middle. Now once you decide to split in the middle, the choice of split is now made, so we are left to design the data structure for L. (Refer Slide Time 12:49) Now if we choose a linked list to make a data structure for L, splitting will again be expensive because you will start from the beginning and split. You will have to scan from the beginning and find out the middle element. On the other hand if you could work it out on an array and if you knew the i th and the j th, the start and the end index then the middle element can be simply chosen by this computation. So if you could know the dimensions, the maximum limits on the array then obviously it is best to use an array. On the other hand even if you don t know after you read all the elements, you just put them into an array, malloc an array of that size, you know these are the elements, you malloc an array of that size and work on that, that will be first split because this split otherwise even for splitting you will take linear time that will not affect the complexity. Overall order n log n will remain because it will only add some more constants to this part. Splitting will take some k 1 n and merging will take some k 2 n and they will add up

5 to form some k 3 n. So you will get T n by 2 plus n by 2 plus some k 3 n which is still the order n log n but you can array the access and the split may be at least constant but n log n is ensured even if you use a linked list. Is that understood? This is how you proceed to do a data structure design, subsequent to the design of the algorithm. Well, let s choose another problem which we have done in a slightly different way. Max and min, the maximum and the minimum of n numbers, similar we will use a similar approach. If L is equal to 1, size of L is equal to 1 then recursively the max and min returns 2 values. Isn t it? It will return a maximum and a minimum, so it returns the structure. So if L is 1 it returns a a, that is which is because L was equal to a in this case, only one element. If L is equal to 2 then it returns a comparison of, suppose L was a b then it compares a greater than b. (Refer Slide Time 16:16) If a is greater than b then it returns b a sorry a, b else it returns b, a, all right. Now two elements, when you come to more than two elements, you split into L 1 and L 2 okay and recursively you will get max 1 and min 1 from solving L 1, all right. You recursively solve max and min L 1 that is you will write max and min L 1 to get max 1, min 1. You recursively solve max and min L 2, to get this. Now you compare max 1 and max 2 to get max is equal to compare max 1 and max 2 and min is equal to compare min 1 and min 2. Isn t it? Suppose this base condition is clear, when L is of size 2 you make one comparison and you will get the maximum and minimum. When L is more than 2 then you split into L 1 and L 2 and you recursively solve L 1, L 1 will return some max 1, min 1, L 2 will return max 2 min 2. The maximum of L will be the larger of max 1 and max 2 and the minimum of L will be the smaller of min 1 and min 2, all right. Any questions? So this is one approach to solve the problem. So let us see what recurrence relation this gives us. This gives us T (n) is equal to 0 if n is equal to 1 is equal to 1 if n is equal to 2 and is equal to T (n 1 ) plus T (n 2 ) plus 2 for n greater than 2, all right. Now where will you split this one, where will

6 you split this? If you choose n 1 equal to 1 and n 2 equal to n minus 1 then can you guess what this will lead to? This will lead to order, work it out 1 plus T (n minus 1) plus 2 sorry 0 (Refer Slide Time: 18:30) that will lead to 0 plus 0 plus T (n minus 2) plus 2 plus 2, 2 (n minus 1). Isn t it? Order n, order n but 2 (n minus 1). (Refer Slide Time 18:56) Now suppose you split in the middle and let us take for example that there are only 2 to the power n elements and you split in the middle then what would you get? T (n) is equal to T (n by 2) plus T (n by 2) plus 2, right. So, suppose this is some 2 to the power k, it will make it easier to analyze, so T (2 to the power k) is twice T (2 to the power k minus 1) plus 2. We have chosen 2 to the power k equal to n, that is suppose n is 16, then 2 to the power 4. So this will, can you solve this? This is 2 into 2 T to the power 2 k minus 2 plus 2 plus 2, right. So that is equal to 2 square T to the power 2 to the power k minus 2 plus 2 square plus 2, 2 to the power i T 2 to the power k minus i, right plus 2 to the power i. Will this term come? Try another term and see if this term comes, 2 square and open up, 2 T to the power k minus 3 plus 2 plus 2 square plus 2. So you will get 2 cube k minus 3 plus 2 cube plus 2 square plus 2, right if you open up.

7 (Refer Slide Time 21:19) So what does this lead to? This 2 to the power 0 will make it up to 0, when this will become 0 when i is k, so 2 to the power k then T (1) plus what? Have I made a mistake somewhere? One minute. If this sums up, it will come to 2 power k plus 1 minus 1. Isn t it? I think I have made a mistake somewhere. No, T (1) is equal to 0, you can cut it out that s alright but this equation was T n 1 plus T n 2 that s fine. I think I have made a mistake somewhere, this is 2 to the power k minus 1, n by 2 is correct plus 2, it s okay. So this comes to twice n minus 1, this is not the correct solution. No, no, no this is not the correct solution, let us work it out for 8 and see how many comparisons come. Let us work it out for n is equal to 8. For 8 you need to make, you split it into 4 and 4. No, no, I have understood where I made my mistake, right, you will not go beyond 2 because your recurrence stops at 2. So we have actually stopped it at 1 but we should have stopped it at 2. Got it? So this part is correct. This whole thing is correct but it could have stopped it at T 2, it need not have gone till T 1, so let us proceed from there. So we were at 2 i T (2 to the power k minus i), this was, this is correct, the expansion is correct but what the mistake we did was we broke the recurrence, we made it 1, 2 to the power 0 that is 1 but the recurrence will stop at 2. So i will be k minus 1, so we will stop at 2 to the power k minus 1 T (2) plus this will be 2 to the power k minus 1, right. Is that understood now? That is the advantage of that T (2) because here we stopped at 2 not 1 and this would give us, how much is this, n by 2 into, T (2) is what? 1 plus n minus 1, so this gives me 3 by 2 n minus 1.

8 (Refer Slide Time 25:19) So now see, while both were order n, splitting in the middle give me slight reduction in the number of comparisons. So I would still split in the middle. But is this the only option? Let us see. If you analyze it a bit more carefully, you will see that in any tree developed like this, see this will split up into things like this given say n it will split up into two parts n 1 and n 2 say n 3 n 4 like this. The leaf nodes will be of two types. If the value, if the n value here that is the number of elements is 1 or 2 and the internal nodes will have more than 1 or 2. Clear? Internal nodes will have more than 1 or 2. Now internal nodes are those nodes were the split occurs and the number of comparison at every internal node is 2. The number of comparisons at every internal node is 2. At the leaf node it is 0 for this and 1 for this. So to solve the problem optimally, what would you do? Suppose you had got 4, the choice here is 4 can be split as 2 2 and 4 can be split as 3 1 and then 3 has to be split as 2 1. Now when ever you split it into 2 here, this is optimal compared to this, just have a look. Now let us see 6. I am not going formally purposely just to 6 could be split as 3 3, this is not 2 to the power n, What is the cost? What is the total cost? 8 and if I split it up, what is the total cost? 7. See even splitting in the middle is not optimal, to get an optimal split you have to analyze the tree. If you minimize the number of internal nodes, you have some external nodes. Now all internal nodes are of maximum cost, the external nodes cannot be both 1 1 unless the internal node is 2. So if you minimize the number of internal nodes, you will get the maximum benefit. I repeat, every internal node is of cost 2, all right. Now if you minimize the number of internal nodes for if there are 2 internal nodes, there have to be only 3. If there are 2 internal nodes then how many external nodes can there be in a tree? If for two internal nodes can there be 4, for 1 internal node there can be 2. So let us take the base condition, for 1 internal node there will be 2 leaf nodes, maximum. Now if there are n internal nodes and there are n plus 1 leaf nodes, if you make 1 internal node for every internal node if

9 you make 2 more leaf node then this will increase by 1, this will increase by 2 because 1 internal node has been reduced and become, one leaf node has become internal node. (Refer Slide Time 30:40) So suppose see take 3, take this case there is 1 internal node and 2 leaf nodes. Now if you increase the number of leaf nodes, you will choose one of them. So one leaf node will go vanish and 2 nodes will get added. So, effectively one leaf node will get added. Isn t it? So you can show that for n internal node, there will be n plus 1 leaf node, maximum in this structure. And though I do not wish to go into more details, you can just analyze it a little and see that if you minimize the number of internal nodes here then you will get the optimal solution not even half half does not optimally split it. That worked because we chose 2 to the power of k and in 2 to the power k, everything will land up in, 2 is at the end. So the choice, a better choice would be if n is even split even even, if n is odd split odd even. If n is odd, one internal node of cost one has to be done. So, if you choose a split this way that if n is even split even even, if n is odd split odd even. You will get the optimal solution. You can work it out in your rooms and check, it is even better than half half because half half will not split in that way. So, one choice is take out 2 at a time, suppose you have got 6 take two at a time out. Suppose you have 9 take 2 at a time It will be optimal because you have split, if it is odd split odd even, it will work and if you split it this way you will always get the optimal solution.

11 1 1 a 1 2 into b 2 1 a 1 3 into b 3 1 that way. So to produce every element, we require n such operations, so to produce n square elements we will require n cube operations. (Refer Slide Time 37:04) Now if you split the problem and multiply it 4 by 4, split it into one fourth size. So you split a into a 1 1 a 1 2 into 4 parts into 4 sub matrices and similarly b and then do a recursive multiplication of them in a very intelligent way then you will be able to deduce this to something order of 2.83, these come from log values. So this algorithm is called the Strassen s algorithm, you must have heard of the name may be. These are all related to how to optimally balance the split. So, this is one aspect of algorithm design. Next day we will have a look at dynamic programming.

### (Refer Slide Time: 06:01)

Data Structures and Algorithms Dr. Naveen Garg Department of Computer Science and Engineering Indian Institute of Technology, Delhi Lecture 28 Applications of DFS Today we are going to be talking about

### (Refer Slide Time: 05:25)

Data Structures and Algorithms Dr. Naveen Garg Department of Computer Science and Engineering IIT Delhi Lecture 30 Applications of DFS in Directed Graphs Today we are going to look at more applications

### Continuing with whatever we saw in the previous lectures, we are going to discuss or continue to discuss the hardwired logic design.

Computer Organization Part I Prof. S. Raman Department of Computer Science & Engineering Indian Institute of Technology Lecture 10 Controller Design: Micro programmed and hard wired (contd) Continuing

### Mathematical Logic Prof. Arindama Singh Department of Mathematics Indian Institute of Technology, Madras. Lecture - 37 Resolution Rules

Mathematical Logic Prof. Arindama Singh Department of Mathematics Indian Institute of Technology, Madras Lecture - 37 Resolution Rules If some literals can be unified, the same algorithm should be able

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

### Finite Element Analysis Prof. Dr. B. N. Rao Department of Civil Engineering Indian Institute of Technology, Madras. Lecture - 36

Finite Element Analysis Prof. Dr. B. N. Rao Department of Civil Engineering Indian Institute of Technology, Madras Lecture - 36 In last class, we have derived element equations for two d elasticity problems

### 6.001 Notes: Section 31.1

6.001 Notes: Section 31.1 Slide 31.1.1 In previous lectures we have seen a number of important themes, which relate to designing code for complex systems. One was the idea of proof by induction, meaning

### Theory of Computation Prof. Raghunath Tewari Department of Computer Science and Engineering Indian Institute of Technology, Kanpur

Theory of Computation Prof. Raghunath Tewari Department of Computer Science and Engineering Indian Institute of Technology, Kanpur Lecture 01 Introduction to Finite Automata Welcome everybody. This is

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

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

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

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

### Paul's Online Math Notes. Online Notes / Algebra (Notes) / Systems of Equations / Augmented Matricies

1 of 8 5/17/2011 5:58 PM Paul's Online Math Notes Home Class Notes Extras/Reviews Cheat Sheets & Tables Downloads Algebra Home Preliminaries Chapters Solving Equations and Inequalities Graphing and Functions

### Solving Linear Recurrence Relations (8.2)

EECS 203 Spring 2016 Lecture 18 Page 1 of 10 Review: Recurrence relations (Chapter 8) Last time we started in on recurrence relations. In computer science, one of the primary reasons we look at solving

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

### Introduction to Access 97/2000

Introduction to Access 97/2000 PowerPoint Presentation Notes Slide 1 Introduction to Databases (Title Slide) Slide 2 Workshop Ground Rules Slide 3 Objectives Here are our objectives for the day. By the

### Introduction to Algorithms / Algorithms I Lecturer: Michael Dinitz Topic: Shortest Paths Date: 10/13/15

600.363 Introduction to Algorithms / 600.463 Algorithms I Lecturer: Michael Dinitz Topic: Shortest Paths Date: 10/13/15 14.1 Introduction Today we re going to talk about algorithms for computing shortest

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

### CSE 373: Data Structures and Algorithms

CSE 373: Data Structures and Algorithms Lecture 19: Comparison Sorting Algorithms Instructor: Lilian de Greef Quarter: Summer 2017 Today Intro to sorting Comparison sorting Insertion Sort Selection Sort

### Introduction to Algorithms

Lecture 1 Introduction to Algorithms 1.1 Overview The purpose of this lecture is to give a brief overview of the topic of Algorithms and the kind of thinking it involves: why we focus on the subjects that

### Intro. Scheme Basics. scm> 5 5. scm>

Intro Let s take some time to talk about LISP. It stands for LISt Processing a way of coding using only lists! It sounds pretty radical, and it is. There are lots of cool things to know about LISP; if

### Digital Image Processing. Prof. P.K. Biswas. Department of Electronics & Electrical Communication Engineering

Digital Image Processing Prof. P.K. Biswas Department of Electronics & Electrical Communication Engineering Indian Institute of Technology, Kharagpur Image Segmentation - III Lecture - 31 Hello, welcome

### Working with recursion

Working with recursion Readings: HtDP, sections 11, 12, 13 (Intermezzo 2). We can extend the idea of a self-referential definition to defining the natural numbers, which leads to the use of recursion in

### Outline: Search and Recursion (Ch13)

Search and Recursion Michael Mandel Lecture 12 Methods in Computational Linguistics I The City University of New York, Graduate Center https://github.com/ling78100/lectureexamples/blob/master/lecture12final.ipynb

### CS61A Discussion Notes: Week 11: The Metacircular Evaluator By Greg Krimer, with slight modifications by Phoebus Chen (using notes from Todd Segal)

CS61A Discussion Notes: Week 11: The Metacircular Evaluator By Greg Krimer, with slight modifications by Phoebus Chen (using notes from Todd Segal) What is the Metacircular Evaluator? It is the best part

### Organizing Spatial Data

Organizing Spatial Data Spatial data records include a sense of location as an attribute. Typically location is represented by coordinate data (in 2D or 3D). 1 If we are to search spatial data using the

### Lesson 14 Transcript: Triggers

Lesson 14 Transcript: Triggers Slide 1: Cover Welcome to Lesson 14 of DB2 on Campus Lecture Series. Today, we are going to talk about Triggers. My name is Raul Chong, and I'm the DB2 on Campus Program

### Object-Oriented Analysis and Design Prof. Partha Pratim Das Department of Computer Science and Engineering Indian Institute of Technology-Kharagpur

Object-Oriented Analysis and Design Prof. Partha Pratim Das Department of Computer Science and Engineering Indian Institute of Technology-Kharagpur Lecture 06 Object-Oriented Analysis and Design Welcome

### B-Trees. Introduction. Definitions

1 of 10 B-Trees Introduction A B-tree is a specialized multiway tree designed especially for use on disk. In a B-tree each node may contain a large number of keys. The number of subtrees of each node,

### Main approach: always make the choice that looks best at the moment.

Greedy algorithms Main approach: always make the choice that looks best at the moment. - More efficient than dynamic programming - Always make the choice that looks best at the moment (just one choice;

### Outline for Today. How can we speed up operations that work on integer data? A simple data structure for ordered dictionaries.

van Emde Boas Trees Outline for Today Data Structures on Integers How can we speed up operations that work on integer data? Tiered Bitvectors A simple data structure for ordered dictionaries. van Emde

### Dr. Amotz Bar-Noy s Compendium of Algorithms Problems. Problems, Hints, and Solutions

Dr. Amotz Bar-Noy s Compendium of Algorithms Problems Problems, Hints, and Solutions Chapter 1 Searching and Sorting Problems 1 1.1 Array with One Missing 1.1.1 Problem Let A = A[1],..., A[n] be an array

### ( ) time in the worst case, but it is

Quicksort: the best of sorts? Weiss calls this the fastest-known sorting algorithm. ( ) time in the worst case, but it is Quicksort takes O N 2 easy to make it use time proportional to N lg N in almost

### Instructor: Craig Duckett. Lecture 03: Tuesday, April 3, 2018 SQL Sorting, Aggregates and Joining Tables

Instructor: Craig Duckett Lecture 03: Tuesday, April 3, 2018 SQL Sorting, Aggregates and Joining Tables 1 Assignment 1 is due LECTURE 5, Tuesday, April 10 th, 2018 in StudentTracker by MIDNIGHT MID-TERM

### We can use a max-heap to sort data.

Sorting 7B N log N Sorts 1 Heap Sort We can use a max-heap to sort data. Convert an array to a max-heap. Remove the root from the heap and store it in its proper position in the same array. Repeat until

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

### The Excel Project: Excel for Accountants, Business People... from the Beginning Duncan Williamson

The Excel Project: Excel for Accountants, Business People... from the Beginning Duncan Williamson Introduction In this book you will see that we use Excel 2007 as the focal point of much of the work we

### MITOCW watch?v=tkwnms5irbu

MITOCW watch?v=tkwnms5irbu 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. To

### Functional abstraction. What is abstraction? Eating apples. Readings: HtDP, sections Language level: Intermediate Student With Lambda

Functional abstraction Readings: HtDP, sections 19-24. Language level: Intermediate Student With Lambda different order used in lecture section 24 material introduced much earlier sections 22, 23 not covered

### 15.4 Longest common subsequence

15.4 Longest common subsequence Biological applications often need to compare the DNA of two (or more) different organisms A strand of DNA consists of a string of molecules called bases, where the possible

### Algorithm classification

Types of Algorithms Algorithm classification Algorithms that use a similar problem-solving approach can be grouped together We ll talk about a classification scheme for algorithms This classification scheme

### i W E I R D U T O P I A i

i W E I R D U T O P I A i CHAPTER 9 1 EXPLODING DOTS CHAPTER 9 WEIRD AND WILD MACHINES All right. It is time to go wild and crazy. Here is a whole host of quirky and strange machines to ponder on, some

### Divide-and-Conquer. Dr. Yingwu Zhu

Divide-and-Conquer Dr. Yingwu Zhu Divide-and-Conquer The most-well known algorithm design technique: 1. Divide instance of problem into two or more smaller instances 2. Solve smaller instances independently

### Dynamic Programming Algorithms

CSC 364S Notes University of Toronto, Fall 2003 Dynamic Programming Algorithms The setting is as follows. We wish to find a solution to a given problem which optimizes some quantity Q of interest; for

### 15-451/651: Design & Analysis of Algorithms January 26, 2015 Dynamic Programming I last changed: January 28, 2015

15-451/651: Design & Analysis of Algorithms January 26, 2015 Dynamic Programming I last changed: January 28, 2015 Dynamic Programming is a powerful technique that allows one to solve many different types

### Lecture 12 March 21, 2007

6.85: Advanced Data Structures Spring 27 Oren Weimann Lecture 2 March 2, 27 Scribe: Tural Badirkhanli Overview Last lecture we saw how to perform membership quueries in O() time using hashing. Today we

### Here are some of the more basic curves that we ll need to know how to do as well as limits on the parameter if they are required.

1 of 10 23/07/2016 05:15 Paul's Online Math Notes Calculus III (Notes) / Line Integrals / Line Integrals - Part I Problems] [Notes] [Practice Problems] [Assignment Calculus III - Notes Line Integrals Part

### Lecture. Algorithm Design and Recursion. Richard E Sarkis CSC 161: The Art of Programming

Lecture Algorithm Design and Recursion Richard E Sarkis CSC 161: The Art of Programming Class Administrivia Objectives To understand the basic techniques for analyzing the efficiency of algorithms To know

### Word: Print Address Labels Using Mail Merge

Word: Print Address Labels Using Mail Merge No Typing! The Quick and Easy Way to Print Sheets of Address Labels Here at PC Knowledge for Seniors we re often asked how to print sticky address labels in

### Introduction to Programming in C Department of Computer Science and Engineering

Introduction to Programming in C Department of Computer Science and Engineering In this lecture, we will see slightly more advanced data type, then a singly link list. We will briefly go over one or two

### : Dimension. Lecturer: Barwick. Wednesday 03 February 2016

18.06.01: Dimension Lecturer: Barwick Wednesday 03 February 2016 What is dimension? Line segments are 1-dimensional; here s one now: Planar regions are 2-dimensional; here s one: Finally, cubes are 3-dimensional:

### Lecture 7 Quicksort : Principles of Imperative Computation (Spring 2018) Frank Pfenning

Lecture 7 Quicksort 15-122: Principles of Imperative Computation (Spring 2018) Frank Pfenning In this lecture we consider two related algorithms for sorting that achieve a much better running time than

### Decisions, Decisions. Testing, testing C H A P T E R 7

C H A P T E R 7 In the first few chapters, we saw some of the basic building blocks of a program. We can now make a program with input, processing, and output. We can even make our input and output a little

### Scan and Quicksort. 1 Scan. 1.1 Contraction CSE341T 09/20/2017. Lecture 7

CSE341T 09/20/2017 Lecture 7 Scan and Quicksort 1 Scan Scan is a very useful primitive for parallel programming. We will use it all the time in this class. First, lets start by thinking about what other

### Lecture 8: Mergesort / Quicksort Steven Skiena

Lecture 8: Mergesort / Quicksort Steven Skiena Department of Computer Science State University of New York Stony Brook, NY 11794 4400 http://www.cs.stonybrook.edu/ skiena Problem of the Day Give an efficient

### 5.5 Completing the Square for the Vertex

5.5 Completing the Square for the Vertex Having the zeros is great, but the other key piece of a quadratic function is the vertex. We can find the vertex in a couple of ways, but one method we ll explore

### 7.3 A randomized version of quicksort

7.3 A randomized version of quicksort 179 7.-6? Argue that for any constant 0< 1=, theprobabilityisapproximately1 that on a random input array, PARTITION produces a split more balanced than 1 to. 7.3 A

### The Running Time of Programs

The Running Time of Programs The 90 10 Rule Many programs exhibit the property that most of their running time is spent in a small fraction of the source code. There is an informal rule that states 90%

### Lecture 5: The Halting Problem. Michael Beeson

Lecture 5: The Halting Problem Michael Beeson Historical situation in 1930 The diagonal method appears to offer a way to extend just about any definition of computable. It appeared in the 1920s that it

### Racket Style Guide Fall 2017

CS17 Integrated Introduction to Computer Science Hughes Racket Style Guide Fall 2017 Contents 1 Introduction 1 2 Naming 1 3 Formatting 1 4 Equality 3 5 Conditionals 4 5.1 Prefer Cond to If......................................

### CSE373: Data Structures and Algorithms Lecture 4: Asymptotic Analysis. Aaron Bauer Winter 2014

CSE373: Data Structures and Algorithms Lecture 4: Asymptotic Analysis Aaron Bauer Winter 2014 Previously, on CSE 373 We want to analyze algorithms for efficiency (in time and space) And do so generally

### Lecture Notes on Quicksort

Lecture Notes on Quicksort 15-122: Principles of Imperative Computation Frank Pfenning Lecture 8 February 5, 2015 1 Introduction In this lecture we consider two related algorithms for sorting that achieve

### Data Structures Lecture 3 Order Notation and Recursion

Data Structures Lecture 3 Order Notation and Recursion 1 Overview The median grade.cpp program from Lecture 2 and background on constructing and using vectors. Algorithm analysis; order notation Recursion

### CSCI-1200 Data Structures Fall 2017 Lecture 13 Problem Solving Techniques

CSCI-1200 Data Structures Fall 2017 Lecture 13 Problem Solving Techniques Review from Lecture 12 Rules for writing recursive functions: 1. Handle the base case(s). 2. Define the problem solution in terms

### Background: disk access vs. main memory access (1/2)

4.4 B-trees Disk access vs. main memory access: background B-tree concept Node structure Structural properties Insertion operation Deletion operation Running time 66 Background: disk access vs. main memory

### Scan and its Uses. 1 Scan. 1.1 Contraction CSE341T/CSE549T 09/17/2014. Lecture 8

CSE341T/CSE549T 09/17/2014 Lecture 8 Scan and its Uses 1 Scan Today, we start by learning a very useful primitive. First, lets start by thinking about what other primitives we have learned so far? The

### Quicksort (CLRS 7) We saw the divide-and-conquer technique at work resulting in Mergesort. Mergesort summary:

Quicksort (CLRS 7) We saw the divide-and-conquer technique at work resulting in Mergesort. Mergesort summary: Partition n elements array A into two subarrays of n/2 elements each Sort the two subarrays

### 1 Introduction. 2 InsertionSort. 2.1 Correctness of InsertionSort

CS 161, Lecture 2 MergeSort, Recurrences 101, and Asymptotic Analysis Scribes: Michael Kim (2015), Ofir Geri (2016), M. Wootters (2017) Date: September 27, 2017 Adapted From Virginia Williams lecture notes

### SORTING. Insertion sort Selection sort Quicksort Mergesort And their asymptotic time complexity

1 SORTING Insertion sort Selection sort Quicksort Mergesort And their asymptotic time complexity See lecture notes page, row in table for this lecture, for file searchsortalgorithms.zip Lecture 11 CS2110

### Lecture 2. 1 Introduction. 2 The Set Cover Problem. COMPSCI 632: Approximation Algorithms August 30, 2017

COMPSCI 632: Approximation Algorithms August 30, 2017 Lecturer: Debmalya Panigrahi Lecture 2 Scribe: Nat Kell 1 Introduction In this lecture, we examine a variety of problems for which we give greedy approximation

### CONTENTS. Functional Maths and Numeracy study guide Name 1) THE FOUR RULES OF ARITHMETIC 6) ROUNDING 2) MEASURES, SHAPE AND SPACE 8) NEGATIVE NUMBERS

Name CONTENTS 1) THE FOUR RULES OF ARITHMETIC Addition (page 2) Addition of decimals (page 4) Subtraction (page 5) Subtraction of decimals (page 8) Subtraction other methods (page 9) Multiplication (page

### (Refer Slide Time: 00:02:04)

Computer Architecture Prof. Anshul Kumar Department of Computer Science and Engineering Indian Institute of Technology, Delhi Lecture - 27 Pipelined Processor Design: Handling Control Hazards We have been

### Trapezoidal decomposition:

Trapezoidal decomposition: Motivation: manipulate/analayze a collection of segments e.g. detect segment intersections e.g., point location data structure Definition. Draw verticals at all points binary

### 15.4 Longest common subsequence

15.4 Longest common subsequence Biological applications often need to compare the DNA of two (or more) different organisms A strand of DNA consists of a string of molecules called bases, where the possible

### UNIT 5B Binary Search

205/09/30 UNIT 5B Binary Search Course Announcements Written exam next week (Wed. Oct 7 ) Practice exam available on the Resources page Exam reviews: Sunday afternoon; watch Piazza for times and places

### Indexing and Hashing

C H A P T E R 1 Indexing and Hashing This chapter covers indexing techniques ranging from the most basic one to highly specialized ones. Due to the extensive use of indices in database systems, this chapter

### Excel Basics Rice Digital Media Commons Guide Written for Microsoft Excel 2010 Windows Edition by Eric Miller

Excel Basics Rice Digital Media Commons Guide Written for Microsoft Excel 2010 Windows Edition by Eric Miller Table of Contents Introduction!... 1 Part 1: Entering Data!... 2 1.a: Typing!... 2 1.b: Editing

### Lecture Overview. 2 Online Algorithms. 2.1 Ski rental problem (rent-or-buy) COMPSCI 532: Design and Analysis of Algorithms November 4, 2015

COMPSCI 532: Design and Analysis of Algorithms November 4, 215 Lecturer: Debmalya Panigrahi Lecture 19 Scribe: Allen Xiao 1 Overview In this lecture, we motivate online algorithms and introduce some of

### Outline for Today. Why could we construct them in time O(n)? Analyzing data structures over the long term.

Amortized Analysis Outline for Today Euler Tour Trees A quick bug fix from last time. Cartesian Trees Revisited Why could we construct them in time O(n)? Amortized Analysis Analyzing data structures over

### Monday. A few notes on homework I want ONE spreadsheet with TWO tabs

CS 1251 Page 1 Monday Sunday, September 14, 2014 2:38 PM A few notes on homework I want ONE spreadsheet with TWO tabs What has passed before We ended last class with you creating a function called givemeseven()

### 2.1 Basics of Functions and Their Graphs

.1 Basics of Functions and Their Graphs Section.1 Notes Page 1 Domain: (input) all the x-values that make the equation defined Defined: There is no division by zero or square roots of negative numbers

### DESIGN AND ANALYSIS OF ALGORITHMS. Unit 1 Chapter 4 ITERATIVE ALGORITHM DESIGN ISSUES

DESIGN AND ANALYSIS OF ALGORITHMS Unit 1 Chapter 4 ITERATIVE ALGORITHM DESIGN ISSUES http://milanvachhani.blogspot.in USE OF LOOPS As we break down algorithm into sub-algorithms, sooner or later we shall

### Introduction to Programming in C Department of Computer Science and Engineering

Introduction to Programming in C Department of Computer Science and Engineering Once we know structures and pointers to structures, we can introduce some very important data structure called link list.

### MergeSort, Recurrences, Asymptotic Analysis Scribe: Michael P. Kim Date: April 1, 2015

CS161, Lecture 2 MergeSort, Recurrences, Asymptotic Analysis Scribe: Michael P. Kim Date: April 1, 2015 1 Introduction Today, we will introduce a fundamental algorithm design paradigm, Divide-And-Conquer,

### Computer Science 210 Data Structures Siena College Fall Topic Notes: Complexity and Asymptotic Analysis

Computer Science 210 Data Structures Siena College Fall 2017 Topic Notes: Complexity and Asymptotic Analysis Consider the abstract data type, the Vector or ArrayList. This structure affords us the opportunity

### Algorithm Design and Analysis

Algorithm Design and Analysis LECTURE 13 Divide and Conquer Closest Pair of Points Convex Hull Strassen Matrix Mult. Adam Smith 9/24/2008 A. Smith; based on slides by E. Demaine, C. Leiserson, S. Raskhodnikova,

### Finding the Volume of Solids

S E S S I O N 1. 5 A Finding the Volume of Solids Math Focus Points Using formulas to find the volume of rectangular prisms Finding the volume of a solid composed of two rectangular prisms Today s Plan

### Drawing Hands, by M. C. Escher (lithograph, 1948)

Drawing Hands, by M. C. Escher (lithograph, 1948) 12 The Leap of Faith In the combining method, we build up to a recursive procedure by writing a number of special-case nonrecursive procedures, starting

### Spreadsheet Concepts Using Microsoft Excel

Spreadsheet Concepts Using Microsoft Excel lab 5 Objectives: Upon successful completion of Lab 5, you will be able to Create and edit a simple spreadsheet document Describe the advantage of using formulas

### CS Data Structures and Algorithm Analysis

CS 483 - Data Structures and Algorithm Analysis Lecture VI: Chapter 5, part 2; Chapter 6, part 1 R. Paul Wiegand George Mason University, Department of Computer Science March 8, 2006 Outline 1 Topological

### Greedy Algorithms II

Greedy Algorithms II Greedy algorithms tend to be difficult to teach since different observations lead to correct greedy algorithms in different situations. Pedagogically, it s somewhat difficult to clearly

### Lecture 21: Red-Black Trees

15-150 Lecture 21: Red-Black Trees Lecture by Dan Licata April 3, 2012 Last time, we talked about the signature for dictionaries: signature ORDERED = sig type t val compare : t * t -> order signature DICT

### Algorithm Design and Recursion. Search and Sort Algorithms

Algorithm Design and Recursion Search and Sort Algorithms Objectives To understand the basic techniques for analyzing the efficiency of algorithms. To know what searching is and understand the algorithms

### One way ANOVA when the data are not normally distributed (The Kruskal-Wallis test).

One way ANOVA when the data are not normally distributed (The Kruskal-Wallis test). Suppose you have a one way design, and want to do an ANOVA, but discover that your data are seriously not normal? Just

### Descriptive Statistics Descriptive statistics & pictorial representations of experimental data.

Psychology 312: Lecture 7 Descriptive Statistics Slide #1 Descriptive Statistics Descriptive statistics & pictorial representations of experimental data. In this lecture we will discuss descriptive statistics.

### Project 2: How Parentheses and the Order of Operations Impose Structure on Expressions

MAT 51 Wladis Project 2: How Parentheses and the Order of Operations Impose Structure on Expressions Parentheses show us how things should be grouped together. The sole purpose of parentheses in algebraic

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