37 III. Growth **of** Functions **Asymptotic** **notation** – The order **of** growth **of** the running time **of** an **algorithm** gives a simple characterization **of** the **algorithms** efficiency. – For input sizes large enough, we make only the order **of** growth **of** the running time relevant, so we study the **asymptotic** efficiency **of** **algorithms**. 38 g(n) is an **asymptotically** tight bound for f(n): Θ(g(n)) = {f(n) : there exist positive constants c1, c2, **and** N such that/

What is the measurement **of** **algorithm**? How to compare two **algorithms**? Definition **of** **Asymptotic** **Notation** Today Topic WAIT… Did we miss something? The resource function! Resource Function Time Function **of** an **algorithm** A Time Function **of** an **algorithm** A Space Function **of** an **algorithm** A Space Function **of** an **algorithm** A Size **of** input Time used Space used We don’t know, yet **And** this one From Experiment We count the number **of** instructions executed Only count/

The **asymptotic** analysis **of** an **algorithm** determines the running time in big-Oh **notation** To perform the **asymptotic** analysis We find the worst-case number **of** primitive operations executed as a function **of** the input size We express this function with big-Oh **notation** Example: We determine that **algorithm** arrayMax executes at most 7n 2 primitive operations We say that **algorithm** arrayMax “runs in O(n) time” Since constant factors **and**/

f (n) be a function. f (n) is the maximum number **of** basic operations performed by the **algorithm** on any input size n. **notation** for efficiency classes – O( ? ) – ( ? ) – ( ? ) Best case, worst case, **and** average case Time Complexity vs. Space Complexity How shall we measure the amount **of** work done by an **algorithm**? Slide 5-81 交大資工 蔡文能 計概 **Asymptotic** Upper Bound (Big O) f(n)f(n) c g(n/

**asymptotic** analysis **of** an **algorithm** determines the running time in big-Oh **notation** To perform the **asymptotic** analysis We find the worst-case number **of** primitive operations executed as a function **of** the input size We express this function with big-Oh **notation** Example: We determine that **algorithm** arrayMax executes at most 6 n 1 primitive operations We say that **algorithm** arrayMax “runs in O(n) time” Since constant factors **and**/

**asymptotic** analysis **of** an **algorithm** determines the running time in big-Oh **notation** To perform the **asymptotic** analysis We find the worst-case number **of** primitive operations executed as a function **of** the input size We express this function with big-Oh **notation** Example: We determine that **algorithm** arrayMax executes at most 6 n 1 primitive operations We say that **algorithm** arrayMax “runs in O(n) time” Since constant factors **and**/

**of** language **and** **notation**. (N. Wirth) The purpose **of** this class is to provide a proper **notation** to deal with these two questions. To achieve this goal, we shall look into algebraic bodies called lattices. – But before, we shall provide some intuition on why the dataflow **algorithms** are correct. How do we know that liveness terminates? Given a control **flow**/p ∈ pred(B) OUT[P] 7: OUT[B] = f b (IN[B]) The **Asymptotic** Complexity **of** the Solver 1.The IN/OUT set associated with a block can change at most H times; hence/

be the c max produced by Delay-Coffman-Graham **algorithm** **and** S* be the c max **of** optimal schedule, then S ≤(S*+p). The **asymptotic** competitive ratio is 1 since S*>>p. 55 Outline Introduction: –Background **and** **Notations** –Three basic scheduling **algorithms** Online Scheduling **of** Precedence Constrained Tasks –Four nonpreemptive scheduling problems –Three preemptive scheduling problems Approximation **Algorithms** for Online Scheduling **of** Equal Processing Time Task System Future Work 56/

big-Oh **notation** To perform the **asymptotic** analysis We find the worst-case number **of** basic operations as a function **of** the input size We express this function with big-Oh **notation** Example: We determine that **algorithm** arrayMax executes at most 8n 2 primitive operations We say that **algorithm** arrayMax “runs in O(n) time” Example: Sequential Search **Algorithm** SequentialSearch(A, x): Input: An array A **and** a target/

Web Workloads Data mining Databases Statistical analysis **and** modeling Graph problems Information visualization Key: data size Theory Big-O **Notation** Big-O **notation** is a method for describing the time or space requirements **of** an **algorithm**. f(x) = O(g(x)) Example/**of** communication to computation ratio is based on the sequence lengths, size **of** the DNA alphabet, **and** number **of** matches: |∑ DNA | n + m + nm nm is the percentage **of** dots that are recorded as matches **and** is the **asymptotic** limit **of** the **algorithm**/

n n 0 this is true for c = 8 **and** n 0 = 2 CPSC 3200 University **of** Tennessee at Chattanooga – Summer 2013 26 2010 Goodrich, Tamassia The **asymptotic** analysis **of** an **algorithm** determines the running time in big-Oh **notation**. To perform the **asymptotic** analysis We find the worst-case number **of** primitive operations executed as a function **of** the input size. We express this function with big-Oh/

whenever) TA: John-Paul Fryckman jfryckm@cs.ucsd.edu CSE 202 - Intro2 What we’ll study General Techniques Divide **and** Conquer, Dynamic Programming, Hashing, Greedy **Algorithms**, Reduction to other problems,... Specific Problems Sorting, sorting, shortest paths, max **flow**, sorting,... Various Paradigms Probabilistic **algorithms** Alternate models **of** computation NP Completeness CSE 202 - Intro3 Sounds like my undergrad course... Going over same material twice is good! We/

**and** sets X, Y, **and** Z returns either yes or no Goal: d-sep(X; Y | Z, G) = yes iff I(X;Y|Z) follows from Markov(G) Paths Intuition: dependency must “**flow**” along paths in the graph A path is a sequence **of**/a small induced width, there are **algorithms** that find it in polynomial time /**notation** Y[1]Y[2] Y[M] Y[M+1] Y|X XX m X[m] Y[m] Query Bayesian Networks **and**/**of** the form N (x i,pa i ) –Parameter estimation Bayesian methods also require choice **of** priors Both MLE **and** Bayesian are **asymptotically** equivalent **and**/

, Simulations **of** granular **flows** from UT Austin **and** CalTech groups Goals: Understanding **of** analytical properties: large energy tails Long time **asymptotics** **and** characterization **of** **asymptotics** states A unified approach for Maxwell type interactions **and** generalizations. / matter phenomena Remark: The numerical **algorithm** is based on the evolution **of** the continuous spectrum **of** the solution as in Greengard-Lin’00 spectral calculation **of** the free space heat kernel, i.e. self-similar **of** the heat equation in all space/

Data Structures (4) Abstract data types **and** their implementations as data structures. Efficient **of** **algorithms** employing these data structures; **asymptotic** analyses. Dictionaries: balanced search trees, hashing. Priority queues: heaps. Disjoint sets with union, find. Graph **algorithms**: shortest path, minimum spanning tree, /**of** Order **Notation** Upper bound:T(n) = O(f(n))Big-O Exist positive constants c **and** n’ such that T(n) c f(n)for all n n’ Lower bound:T(n) = (g(n))Omega Exist positive constants c **and**/

by choice **of** **algorithm** but also by changing the way disk is used **and** memory is accessed. Disk **and** network traffic Because **of** the sophistication **of** current disk drives **and** the complexity **of** their interaction with CPU **and** OS, exact mathematical descriptions **of** **algorithm** behavior are unattainable; broad approximations are often the only manageable way **of** describing disk performance. 7. **Algorithms** GNU OSLabWriting for Computer Science 5 **Asymptotic** complexity Define : Big-O **notation** a function/

**and** space complexity Time is the number **of** steps required to solve a problem **of** size n. We are looking for the worst-case **asymptotic** bound on the step count (not an exact count). **Asymptotic** behavior is the limiting behavior as n tends to a large number. 21 Complexity **of** **Algorithms** An **algorithm**/– a quadratic polynomial. Other examples are minimum spanning tree, max **flow** network etc. The solutions for the above problems are tractable 22 Complexity **of** **Algorithms** Exponential time O(c n ) where is c is a positive/

analytical properties: large energy tails Long time **asymptotics** **and** characterization **of** **asymptotics** states Long time **asymptotics** **and** characterization **of** **asymptotics** states A unified approach for Maxwell type interactions **and** generalizations. A unified approach for Maxwell type interactions **and** generalizations. Spectral-Lagrangian solvers for dissipative interactionsSpectral-Lagrangian solvers for dissipative interactions Simulations **of** granular **flows** from UT Austin **and** CalTech groupsUT Austin CalTech Part I/

must specify the requirements **of** the software system Must be based on accurate information Various techniques: – discussions **and** negotiations with the client – modeling the problem structure **and** data **flow** – observation **of** client activities – analysis **of** existing solutions **and** systems Copyright © 2005/ **of** the **algorithm** We often use Big-Oh **notation** to specify the order, such as O(n 2 ) Copyright © 2005 Pearson Addison-Wesley. All rights reserved. 1-30 FIGURE 1.11 Some growth functions **and** their **asymptotic** /

**algorithm** that makes efficient use **of** the computer’s resources. **Algorithm** Efficiency (cont) Goal (1) is the concern **of** Software Engineering. Goal (2) is the concern **of** data structures **and** **algorithm** analysis. When goal (2) is important, how do we measure an **algorithm**’s cost? How to Measure Efficiency? 1.Empirical comparison (run programs) 2.**Asymptotic** **Algorithm**/LIFO: Last In, First Out. Restricted form **of** list: Insert **and** remove only at front **of** list. **Notation**: Insert: PUSH Remove: POP The accessible element /

metrics **of** the larger unchanged chip beyond pre-set bounds (e.g., <= 10% increase in wire-length) Use **of** a new network-**flow** /**and** need expertise to use. This project aims to develop techniques to profit from both types **of** languages. Transformation based approach Design an **algorithmic** approach to transform UML diagrams systematically into a formal **notation**/. Extend the analysis to large random networks. Derive low-complexity **asymptotically**-optimal Network & Channel code pairs. Extend to interference networks, /

-**flow** example? As advanced any irregular fine-grained parallel **algorithms** dared on any parallel architecture - Horizons **of** a computer architecture cannot only be studied using elementary **algorithms** [Performance, efficiency **and** effectiveness **of** a car not tested only in low gear or limited road conditions] - Stress test for important architecture capabilities not often discussed: 1.Strong scaling : Increase #processors, not problem size 2.Rewarding even little amounts **of** **algorithm**/

**algorithm** that makes efficient use **of** the computer’s resources. **Algorithm** Efficiency (cont) Goal (1) is the concern **of** Software Engineering. Goal (2) is the concern **of** data structures **and** **algorithm** analysis. When goal (2) is important, how do we measure an **algorithm**’s cost? How to Measure Efficiency? 1.Empirical comparison (run programs) 2.**Asymptotic** **Algorithm**/LIFO: Last In, First Out. Restricted form **of** list: Insert **and** remove only at front **of** list. **Notation**: Insert: PUSH Remove: POP The accessible element /

-hop wireless networks. Next we will focus on the **asymptotic** analysis **of** network capacity **of** multi-hop wireless networks. Major results in this research area are presented based on concise explanations about how they are derived. Major results in this research area are presented based on concise explanations about how they are derived. 14 15 **Notations** **and** Terms O(·): A Landau symbol. Given f = O/

**and** debugging – maintenance **and** evolution 1-6 Problem Specification We must specify the requirements **of** the software system Must be based on accurate information Various techniques: – discussions **and** negotiations with the client – modeling the problem structure **and** data **flow** – observation **of** client activities – analysis **of** existing solutions **and**/the order **of** the **algorithm** We often use Big-Oh **notation** to specify the order, such as O(n 2 ) 1-25 FIGURE 1.11 Some growth functions **and** their **asymptotic** complexity /

Avishai Mandelbaum 2 **Flow** **of** the Talk Environments with heterogeneous customers Call Centers: Overview Background – exact **and** **asymptotic** results Erlang-C with priorities Erlang-A with priorities **Asymptotic** results: the lowest priority **Asymptotic** results: other priorities Additional results **and** future research 3 /1 1 L L 1 + Non-Preemptive Priority: Transition-Rate Diagram 18 Non-Preemptive Priority: K Types The **Algorithm** Step 1: Step 2: ”Merge” the first k types to a single type with Step 3: 19 Towards/

often an implementation **of** an ADT **Algorithm** Analysis Problem Solving Space Complexity Time Complexity Classifying Functions by Their **Asymptotic** Growth 1. Problem Definition What is the task to be accomplished? Calculate the average **of** the grades for /year to run to completion **Algorithms** running time is an important issue Pseudo Code **and** **Flow** Charts Basic elements **of** Pseudo code Basic operations **of** Pseudo code **Flow** Chart Symbols used in **flow** charts Examples Pseudo Code **and** **Flow** Charts There are two commonly/

, Fundamental ConceptsSlide 4 Some Commonly Encountered Growth Rates **Notation** Class nameNotes O(1) ConstantRarely practical O(log log/**asymptotic** analysis. A question **of** interest is whether or not the **algorithm** at hand is the best **algorithm** for solving the problem? 3.2. **Algorithm** Optimality **And** Efficiency Winter 2014Parallel Processing, Fundamental ConceptsSlide 7 3.2. **Algorithm** Optimality **And** Efficiency What is the running timeƒ(n) **of** the fastest **algorithm** for solving this problem? **Of** course, **algorithm**/

All value **flows** between typed **and** untyped parts have to be monitored by casts Paraphrase **of** Type /if (x : Dyn bool ) then “true” else “false” Blame calculus **Notation** typed code untyped code cast let x = Dyn if…then succ Dyn else / Data structures Data structures are crucial to design **algorithms** Efficient, correct **algorithms** need fine- grained specifications on data structures E/**of** both worlds E.g., tails **of** sorted lists are merely lists Checking specs at run time can worsen **asymptotic** time complexity Pros **and**/

solutions Space inhomogeneous problems Time splitting **algorithms** Simulations **of** boundary value – layers problems Benchmark simulations Part III A general form statistical transport : The space-homogenous BTE with external heating sources Important examples from mathematical physics **and** social sciences: The term models external heating sources: background thermostat (linear collisions), thermal bath (diffusion) shear **flow** (friction), dynamically scaled long time limits (self-similar solutions). Inelastic/

Hill, 2002. Lecture slides online Other reference: The Design **and** Analysis **of** Computer **Algorithms**, A.V. Aho, J.E. Hopcroft **and** J.D. Ullman Jan. 20156 Course Roadmap **Algorithmics** Basics Divide **and** Conquer Sorting **and** Selection Search Trees Graph **Algorithms** Dynamic Programming Greedy **Algorithms** Selected Topics Randomized **Algorithms** Jan. 20157 **Algorithmics** Basics Introduction to **algorithms**, complexity, **and** proof **of** correctness. (Chapters 1 & 2) **Asymptotic** **Notation**. (Chapter 3.1) Goals –Know how to write formal/

Lectures 24 **and** above Java Virtual Machine Distributed Systems **and** Cloud Computing Balancing Trees (e.g.: AVL trees) But do know what a balanced **and** unbalanced tree is Recurrences Network **Flow** Primitive Types boolean, int, double, etc… Test equality with == **and** != Compare with, **and** >= Typing void/2 + n + 2: 2n 3 is the dominant term **Asymptotic** Complexity Meaning **of** c Cannot get a precise measurement Famous election recounts (Bush/Gore, Coleman/Franken) **Algorithm**’s speed on a 2 GHz versus a 1 GHz processor /

**of** distributions into their underlying components. Maximum likelihood solution based on assumption **of** two univariate normal distributions with unequal variances. Expectation – maximisation (EM) **algorithm** to estimate means 1 **and** 2 **and** variances 1 **and** 2 **of**/ area **and** forest plus agriculture area), animal density (ANI), average annual precipitation (PRE) **and** **flow** (FLO). Concentration **of** total phosphorus (CTP), concentration **of** ortho-phosphorus (COP), export **of** total phosphorus (ETP) **and** export **of** ortho-/

**Algorithmic** Graph Theory **and** Perfect Graphs [GOLU04]: Complexity **of** determining whether an n-vertex graph is planar ExponentialKuratowski1930 O(n 3 )Auslander **and** Porter1961 Goldstein1963 Shirey1969 O(n 2 )Lempel, Even, **and** Cederbaum1967 O(n log n)Hopcroft **and** Tarjan1972 O(n)Hopcroft **and** Tarjan1974 Booth **and** Leuker1976 A second, more complex example: Max network **flow**/Given f(n) = a f(n/b) + h(n); a, b constant, h arbitrary function the **asymptotic** solution to the recurrence is (c = log b a) f(n) = (n c )if /

l Part 1: Elements **of** graph-theory: –Terminology, **notations**, **algorithms** on graphs l Part 2: Graph-based **algorithms** for IR –Web search –Text clustering **and** classification l Part 3: Graph-based **algorithms** for NLP –Word Sense Disambiguation –Clustering **of** entities (names/numbers)/-**flow** **algorithms**, with polynomial **asymptotic** running times l Use the min-cut / max-**flow** **algorithm** RANLP 2005 134 Cut-based **Algorithm** (cont.) Notice that without the structural information we would be undecided about the assignment **of** /

operations. Crude but valuable measure **of** **algorithm** ’ s performance as a function **of** input size. 44 Average, Best, **and** Worst-Case On which input instances should the **algorithm** ’ s performance be judged? n Average case: Real world distributions difficult to predict n Best case: Seems unrealistic n Worst case: Gives an absolute guarantee We will use the worst-case measure. 45 **Asymptotic** **Notation** Review Big-O, “ bounded/

the capacity to produce populations **of** infinite size, but environments **and** resources are finite. The distribution **and** abundance **of** organisms **and** populations in ecosystems are limited by the availability **of** matter **and** energy **and** the ability **of** the ecosystem to recycle materials. Principles that Underlie the Concept **and**/or Skill: Matter **and** energy **flow** **and** conservation Living systems require continuous energy input. Matter **and** energy are conserved as they **flow** through **and** between organisms. Some energy/

operations. Crude but valuable measure **of** **algorithm** ’ s performance as a function **of** input size. 64 Average, Best, **and** Worst-Case On which input instances should the **algorithm** ’ s performance be judged? n Average case: Real world distributions difficult to predict n Best case: Seems unrealistic n Worst case: Gives an absolute guarantee We will use the worst-case measure. 65 **Asymptotic** **Notation** Review Big-O, “ bounded/

1) Primitive data structure. int, char, float. 2) Non-Primitive data structure. arrays, structure **and** files. TOPICS COVERED: 1)**Algorithms**. 2)Analysis **of** **algorithm**. 3) Analysis **of** **algorithms** using data structures. 4) Performance Analysis 4.1) Time Complexity. 4.2) Space Complexity. 4.3) Amortized time Complexity. 5) **Asymptotic** **notation**. 1.1 Definition: An **algorithm** consists **of** a set **of** explicit **and** unambiguous, finite steps when carrying out for a given set/

(responded existence) Whenever B is performed, C must be performed afterwards **and** B can not be repeated until C is done (alternate response) The **notation** here is based on [AalstEtAl06, MaggiEtAl11] (DecSerFlow, Declare)AalstEtAl06 MaggiEtAl11/**and** global statistics on the mutual order **of** appearance **of** events for further fast querying Performances: the **algorithm** is proven to be fast (over 12m events processed in less than 170 secs.) **Asymptotically**: linear in the number **of** the traces quadratic in the number **of**/

..... Why Use Big-O **Notation** Used when we only know the **asymptotic** upper bound. –What does **asymptotic** mean? –What does upper bound mean? If you are not guaranteed certain input, then it is a valid upper bound that even the worst-case input will be below. Why worst-case? May often be determined by inspection **of** an **algorithm**. Two Categories **of** **Algorithms** 2 4 8 16 32/

random coin flips R are independent **of** the input. Actually my **algorithm** always gives the right answer. **And** for EVERY input I, the expected running time (over choice **of** R) is great. There are/ e d f g hC2C2 Last Update: Dec 4, 2014 Properties **Notation** nnumber **of** vertices mnumber **of** edges deg(v)degree **of** vertex v Property 1 v deg(v) = 2m Proof: /256 Primal-Dual Hill Climbing No Gap **Flow** alg witness that network has this **flow**. Cut alg witness that network has no bigger **flow**. Prove: For every location to stand/

Example **of** **Algorithm** Sorting some disordered data Bubble sort Quick sort Example – Bubble Sort A step-by-step example Example – Quick Sort A step-by-step example Example – Comparison In general, quick sort can be much more faster than bubble sort. However, there are some issues when making comparison A quantitative comparison? Is there a worst case? Computational Complexity Big O **notation** (infinite **asymptotics**/

1 step = 1 ns **Algorithm** analysis 2 ways –Exact: “count” exact number **of** operations –**Asymptotic**: find **asymptotic** or upper bound Amortization –Technique to simplify calculation –E.g. consider effect **of** occasional time penalties Exact analysis Not done often, only for small parts **of** code We want # assembly /to show that f(n) is O(g(n)) How do we show this is true using the definition? –We need to specify values **of** c **and** n 0. –We want to show that 7n 2 + 8n + 11 <= c n 2 for sufficiently large n. –Note that 7n/

, 2004. 5. Tanaenbaum A. S. Langram, Y. Augestein M.J, “Data Structures using C”,Pearson Education, 2004. INTRODUCTION UNIT-1 Fundamentals **of** **Algorithm** Analysis **of** **Algorithm** Performance Analysis Time complexity Space complexity **Asymptotic** **Notations** UNIT-2 Fundamentals **of** Data Structure Arrays Structures Stacks **and** its Application Queue **and** its Representation Linked List STACKSQUEUES UNIT-3 Trees Binary Search Trees Binary Tree Traversal Post-Order Pre-Order In-Order Sorting/

are the curves increasing?Why do there reach an **asymptote**? What is TH when N= 0? What is the limit **of** TH as N tends to infinity? Why are/**of** the most efficient ones **and** can be extended to other systems such as assembly lines. Focus on Continuous **flow** model but all results can be extended to discrete **flow** models M1 B1 M2 B2 M3 B3 M4 75 **Notation**/ d (i) E(i), ps(i), pb(i) are functions **of** u (i), u (i), d (i), d (i) Decomposition method Decomposition 87 DDX **Algorithm**: Step 1: Initialisation u (i) = i, u (i)/

efficiency E(s, n) = 1 for all **algorithms** with any number **of** processors **and** any size problem s. Scalability Definition (more formal): The scalability (s, n) **of** a machine for a given **algorithm** is defined as the ratio **of** the **asymptotic** speedup S(s,n) on the real machine to the **asymptotic** speedup S I (s, n) On the ideal realization **of** an EREW PRAM EECC756 - Shaaban #78 Exam/

a **flow** in G. Then: ä Implicit summation **notation**: source: 91.503 textbook Cormen et al. Exercise: show source: Sedgewick, Graph **Algorithms** **Flow** Properties (continued) **Flow** Equilibrium A = amount **of** **flow** into left set from outside right set B = amount **of** **flow** out **of** left set (**and** not into right set) C = amount **of** **flow** into right set from outside left set D = amount **of** **flow** out **of** right set (**and** not into left set) y = amount **of** **flow** into/

Programming with Python Part I: Controlling the **flow** **of** your program Reference: How to Think Like/No need to retype your functions Keep a single group **of** related functions **and** declarations in each file 8 Why Functions? Powerful mechanism for/**algorithms** independently from a specific implementation, software or hardware? 21 Runtime Complexity Big O **Notation** Big Idea Measure the number **of** steps taken by the **algorithm** as a **asymptotic** function **of** the size **of** its input What is a step? How can we measure the size **of**/

**Asymptotic** Growth Pseudo Code **and** **Flow** Charts Basic elements **of** Pseudo code Basic operations **of** Pseudo code **Flow** Chart Symbols used in **flow** charts Examples Pseudo Code **and** **Flow** Charts There are two commonly used tools to help to document program logic (the **algorithm**/notion **of** an ordered sequence **of** operations Furthermore we introduce a dot **notation** (e.g. 3.1 come after 3 but before 4) to number subordinate operations for conditional **and** iterative operations Each instruction should be unambiguous **and** /

Ads by Google