Dynamic programming in Algorithm Analysis

Feb 8, 2017Download as ppt, pdf

2 likes1,755 views

The document discusses dynamic programming and amortized analysis. It covers: 1) An example of amortized analysis of dynamic tables, where the worst case cost of an insert is O(n) but the amortized cost is O(1). 2) Dynamic programming can be used when a problem breaks into recurring subproblems. Longest common subsequence is given as an example that is solved using dynamic programming in O(mn) time rather than a brute force O(2^m*n) approach. 3) The dynamic programming algorithm for longest common subsequence works by defining a 2D array c where c[i,j] represents the length of the LCS of the first i elements

David Luebke 1
CS 332: Algorithms
Dynamic Programming

David Luebke 2
Review: Amortized Analysis
● To illustrate amortized analysis we examined
dynamic tables
1. Init table size m = 1
2. Insert elements until number n > m
3. Generate new table of size 2m
4. Reinsert old elements into new table
5. (back to step 2)
● What is the worst-case cost of an insert?
● What is the amortized cost of an insert?

Most read

David Luebke 3
Review:
Analysis Of Dynamic Tables
● Let ci = cost of ith insert
● ci = i if i-1 is exact power of 2, 1 otherwise
● Example:
■ Operation Table Size Cost
Insert(1) 1 1 1
Insert(2) 2 1 + 1 2
Insert(3) 4 1 + 2
Insert(4) 4 1
Insert(5) 8 1 + 4
Insert(6) 8 1
Insert(7) 8 1
Insert(8) 8 1
Insert(9) 16 1 + 8
1
2
3
4
5
6
7
8
9

David Luebke 4
Review: Aggregate Analysis
● n Insert() operations cost
● Average cost of operation
= (total cost)/(# operations) < 3
● Asymptotically, then, a dynamic table costs
the same as a fixed-size table
■ Both O(1) per Insert operation
nnnnc
n
j
j
n
i
i 3)12(2
lg
01
<−+=+≤ ∑∑ ==

David Luebke 5
Review: Accounting Analysis
● Charge each operation $3 amortized cost
■ Use $1 to perform immediate Insert()
■ Store $2
● When table doubles
■ $1 reinserts old item, $1 reinserts another old item
■ We’ve paid these costs up front with the last n/2
Insert()s
● Upshot: O(1) amortized cost per operation

David Luebke 6
Review: Accounting Analysis
● Suppose must support insert & delete, table
should contract as well as expand
■ Table overflows ⇒ double it (as before)
■ Table < 1/4 full ⇒ halve it
■ Charge $3 for Insert (as before)
■ Charge $2 for Delete
○ Store extra $1 in emptied slot
○ Use later to pay to copy remaining items to new table
when shrinking table
● What if we halve size when table < 1/8 full?

David Luebke 7
Dynamic Programming
● Another strategy for designing algorithms is
dynamic programming
■ A metatechnique, not an algorithm
(like divide & conquer)
■ The word “programming” is historical and
predates computer programming
● Use when problem breaks down into recurring
small subproblems

David Luebke 8
Dynamic Programming Example:
Longest Common Subsequence
● Longest common subsequence (LCS) problem:
■ Given two sequences x[1..m] and y[1..n], find the
longest subsequence which occurs in both
■ Ex: x = {A B C B D A B }, y = {B D C A B A}
■ {B C} and {A A} are both subsequences of both
○ What is the LCS?
■ Brute-force algorithm: For every subsequence of x,
check if it’s a subsequence of y
○ How many subsequences of x are there?
○ What will be the running time of the brute-force alg?

David Luebke 9
LCS Algorithm
● Brute-force algorithm: 2m
subsequences of x to
check against n elements of y: O(n 2m
)
● We can do better: for now, let’s only worry
about the problem of finding the length of LCS
■ When finished we will see how to backtrack from
this solution back to the actual LCS
● Notice LCS problem has optimal substructure
■ Subproblems: LCS of pairs of prefixes of x and y

David Luebke 10
Finding LCS Length
● Define c[i,j] to be the length of the LCS of
x[1..i] and y[1..j]
■ What is the length of LCS of x and y?
● Theorem:
● What is this really saying?



−−
=+−−
=
otherwise]),1[],1,[max(
],[][if1]1,1[
],[
jicjic
jyixjic
jic

The document discusses dynamic programming, including its meaning, definition, uses, techniques, and examples. Dynamic programming refers to breaking large problems down into smaller subproblems, solving each subproblem only once, and storing the results for future use. This avoids recomputing the same subproblems repeatedly. Examples covered include matrix chain multiplication, the Fibonacci sequence, and optimal substructure. The document provides details on formulating and solving dynamic programming problems through recursive definitions and storing results in tables.

DynamicpgmmingMuhammad Wasif

This document discusses dynamic programming and provides examples to illustrate the technique. It begins by defining dynamic programming as a bottom-up approach to problem solving where solutions to smaller subproblems are stored and built upon to solve larger problems. It then provides examples of dynamic programming algorithms for calculating Fibonacci numbers, binomial coefficients, and finding shortest paths using Floyd's algorithm. The key aspects of dynamic programming like avoiding recomputing solutions and storing intermediate results in tables are emphasized.

Dynamic programmingGopi Saiteja

This document discusses the concept of dynamic programming. It provides examples of dynamic programming problems including assembly line scheduling and matrix chain multiplication. The key steps of a dynamic programming problem are: (1) characterize the optimal structure of a solution, (2) define the problem recursively, (3) compute the optimal solution in a bottom-up manner by solving subproblems only once and storing results, and (4) construct an optimal solution from the computed information.

Dynamic programmingYıldırım Tam

Divide&Conquer & Dynamic ProgrammingGuillaume Guérard

The document discusses three fundamental algorithms paradigms: recursion, divide-and-conquer, and dynamic programming. Recursion uses method calls to break down problems into simpler subproblems. Divide-and-conquer divides problems into independent subproblems, solves each, and combines solutions. Dynamic programming breaks problems into overlapping subproblems and builds up solutions, storing results of subproblems to avoid recomputing them. Examples like mergesort and calculating Fibonacci numbers are provided to illustrate the approaches.

Introduction to dynamic programmingAmisha Narsingani

Dynamic programming is an algorithm design technique for optimization problems that reduces time by increasing space usage. It works by breaking problems down into overlapping subproblems and storing the solutions to subproblems, rather than recomputing them, to build up the optimal solution. The key aspects are identifying the optimal substructure of problems and handling overlapping subproblems in a bottom-up manner using tables. Examples that can be solved with dynamic programming include the knapsack problem, shortest paths, and matrix chain multiplication.

5.3 dynamic programming 03Krish_ver2

Dynamic programming is an algorithm design paradigm that can be applied to problems exhibiting optimal substructure and overlapping subproblems. It works by breaking down a problem into subproblems and storing the results of already solved subproblems, rather than recomputing them multiple times. This allows for an efficient bottom-up approach. Examples where dynamic programming can be applied include the matrix chain multiplication problem, the 0-1 knapsack problem, and finding the longest common subsequence between two strings.

Dynamic programming class 16Kumar

Dynamic programming is an algorithm design technique that solves problems by breaking them down into smaller overlapping subproblems and storing the results of already solved subproblems, rather than recomputing them. It is applicable to problems exhibiting optimal substructure and overlapping subproblems. The key steps are to define the optimal substructure, recursively define the optimal solution value, compute values bottom-up, and optionally reconstruct the optimal solution. Common examples that can be solved with dynamic programming include knapsack, shortest paths, matrix chain multiplication, and longest common subsequence.

DPSubba Oota

Dynamic programming is an algorithmic technique that solves problems by breaking them down into smaller subproblems and storing the results of subproblems to avoid recomputing them. It is useful for optimization problems with overlapping subproblems. The key steps are to characterize the structure of an optimal solution, recursively define the value of an optimal solution, compute that value, and construct the optimal solution. Examples discussed include rod cutting, longest increasing subsequence, longest palindrome subsequence, and palindrome partitioning. Other problems that can be solved with dynamic programming include edit distance, shortest paths, optimal binary search trees, the traveling salesman problem, and reliability design.

Lecture 8 dynamic programmingOye Tu

This document discusses algorithms for finding minimum and maximum elements in an array, including simultaneous minimum and maximum algorithms. It introduces dynamic programming as a technique for improving inefficient divide-and-conquer algorithms by storing results of subproblems to avoid recomputing them. Examples of dynamic programming include calculating the Fibonacci sequence and solving an assembly line scheduling problem to minimize total time.

Dynamic programmingAmit Kumar Rathi

(1) Dynamic programming is an algorithm design technique that solves problems by breaking them down into smaller subproblems and storing the results of already solved subproblems. (2) It is applicable to problems where subproblems overlap and solving them recursively would result in redundant computations. (3) The key steps of a dynamic programming algorithm are to characterize the optimal structure, define the problem recursively in terms of optimal substructures, and compute the optimal solution bottom-up by solving subproblems only once.

Dynamic programming - fundamentals reviewElifTech

dynamic programming Rod cutting classgiridaroori

The document discusses the dynamic programming approach to solving the Fibonacci numbers problem and the rod cutting problem. It explains that dynamic programming formulations first express the problem recursively but then optimize it by storing results of subproblems to avoid recomputing them. This is done either through a top-down recursive approach with memoization or a bottom-up approach by filling a table with solutions to subproblems of increasing size. The document also introduces the matrix chain multiplication problem and how it can be optimized through dynamic programming by considering overlapping subproblems.

Dynamic pgmmingDr. C.V. Suresh Babu

This document provides an overview of dynamic programming. It begins by explaining that dynamic programming is a technique for solving optimization problems by breaking them down into overlapping subproblems and storing the results of solved subproblems in a table to avoid recomputing them. It then provides examples of problems that can be solved using dynamic programming, including Fibonacci numbers, binomial coefficients, shortest paths, and optimal binary search trees. The key aspects of dynamic programming algorithms, including defining subproblems and combining their solutions, are also outlined.

unit-4-dynamic programminghodcsencet

Dynamic programming is used to solve optimization problems by combining solutions to overlapping subproblems. It works by breaking down problems into subproblems, solving each subproblem only once, and storing the solutions in a table to avoid recomputing them. There are two key properties for applying dynamic programming: overlapping subproblems and optimal substructure. Some applications of dynamic programming include finding shortest paths, matrix chain multiplication, the traveling salesperson problem, and knapsack problems.

Dynamic programming1debolina13

The document discusses the dynamic programming approach to solving the matrix chain multiplication problem. It explains that dynamic programming breaks problems down into overlapping subproblems, solves each subproblem once, and stores the solutions in a table to avoid recomputing them. It then presents the algorithm MATRIX-CHAIN-ORDER that uses dynamic programming to solve the matrix chain multiplication problem in O(n^3) time, as opposed to a brute force approach that would take exponential time.

Dynamic programming BasicsKvishnu Dahatonde

Matrix chain multiplicationRespa Peter

Dynamic ProgrammingSahil Kumar

Daa:Dynamic Programingrupali_2bonde

Dynamic programming is used to solve optimization problems by breaking them down into subproblems. It solves each subproblem only once, storing the results in a table to lookup when the subproblem recurs. This avoids recomputing solutions and reduces computation. The key is determining the optimal substructure of problems. It involves characterizing optimal solutions recursively, computing values in a bottom-up table, and tracing back the optimal solution. An example is the 0/1 knapsack problem to maximize profit fitting items in a knapsack of limited capacity.

Introduction to Dynamic Programming, Principle of OptimalityBhavin Darji

DS pptkirupasuchi1996

Dynamic programming is a mathematical optimization method and computer programming technique used to solve complex problems by breaking them down into simpler subproblems. It was developed by Richard Bellman in the 1950s and has been applied in many fields. Dynamic programming problems can be solved optimally by breaking them into subproblems with optimal substructures that can be solved recursively. It uses techniques like top-down or bottom-up approaches and storing results of subproblems to solve larger problems efficiently by avoiding recomputing the common subproblems. Multistage graphs are a type of problem well-suited for dynamic programming solutions using techniques like greedy algorithms, Dijkstra's algorithm, or dynamic programming to find shortest paths. Traversal and search algorithms like breadth-

Dynamic Programming - Part 1Amrinder Arora

This document discusses dynamic programming techniques. It covers matrix chain multiplication and all pairs shortest paths problems. Dynamic programming involves breaking down problems into overlapping subproblems and storing the results of already solved subproblems to avoid recomputing them. It has four main steps - defining a mathematical notation for subproblems, proving optimal substructure, deriving a recurrence relation, and developing an algorithm using the relation.

daa-unit-3-greedy methodhodcsencet

The document discusses the greedy method algorithmic approach. It provides an overview of greedy algorithms including that they make locally optimal choices at each step to find a global optimal solution. The document also provides examples of problems that can be solved using greedy methods like job sequencing, the knapsack problem, finding minimum spanning trees, and single source shortest paths. It summarizes control flow and applications of greedy algorithms.

Greedy AlgorithmsAmrinder Arora

Matrix mult class-17Kumar

The document discusses the matrix chain multiplication problem, which involves finding the most efficient way to multiply a sequence of matrices by determining the optimal parenthesization. It describes that there are multiple ways to multiply the matrices and lists an example of different possibilities. It then introduces a dynamic programming approach to solve this problem in polynomial time by treating it as the combination of optimal solutions to subproblems. The algorithm works by computing a minimum cost table and split table to track the optimal way to multiply the matrices.

Randomized Algorithms in Linear Algebra & the Column Subset Selection ProblemWei Xue

1) The document discusses randomized algorithms for linear algebra problems like matrix decomposition and column subset selection. 2) It describes how sampling rows/columns of a matrix using random projections can create smaller matrices that approximate the original well. 3) The talk will illustrate applications of these ideas to the column subset selection problem and approximating low-rank matrix decompositions.

Chap08algMunkhchimeg

The document describes several algorithms for dynamic programming and graph algorithms: 1. It presents four algorithms for computing the Fibonacci numbers using dynamic programming with arrays or recursion with and without memoization. 2. It provides algorithms for solving coin changing and matrix multiplication problems using dynamic programming by filling out arrays. 3. It gives algorithms to find the length and a longest common subsequence between two strings using dynamic programming. 4. It introduces algorithms to find shortest paths between all pairs of vertices in a weighted graph using Floyd's and Warshall's algorithms. It includes algorithms to output a shortest path between two vertices.

More Related Content

What's hot (20)

5.3 dynamic programming 03Krish_ver2

Dynamic programming class 16Kumar

DPSubba Oota

Lecture 8 dynamic programmingOye Tu

Dynamic programmingAmit Kumar Rathi

Dynamic programming - fundamentals reviewElifTech

dynamic programming Rod cutting classgiridaroori

Dynamic pgmmingDr. C.V. Suresh Babu

unit-4-dynamic programminghodcsencet

Dynamic programming1debolina13

Dynamic programming BasicsKvishnu Dahatonde

Matrix chain multiplicationRespa Peter

Dynamic ProgrammingSahil Kumar

Daa:Dynamic Programingrupali_2bonde

Introduction to Dynamic Programming, Principle of OptimalityBhavin Darji

DS pptkirupasuchi1996

Dynamic Programming - Part 1Amrinder Arora

daa-unit-3-greedy methodhodcsencet

Greedy AlgorithmsAmrinder Arora

Matrix mult class-17Kumar

5.3 dynamic programming 03Krish_ver2

Dynamic programming class 16Kumar

DPSubba Oota

Lecture 8 dynamic programmingOye Tu

Dynamic programmingAmit Kumar Rathi

Dynamic programming - fundamentals reviewElifTech

dynamic programming Rod cutting classgiridaroori

Dynamic pgmmingDr. C.V. Suresh Babu

unit-4-dynamic programminghodcsencet

Dynamic programming1debolina13

Dynamic programming BasicsKvishnu Dahatonde

Matrix chain multiplicationRespa Peter

Dynamic ProgrammingSahil Kumar

Daa:Dynamic Programingrupali_2bonde

Introduction to Dynamic Programming, Principle of OptimalityBhavin Darji

DS pptkirupasuchi1996

Dynamic Programming - Part 1Amrinder Arora

daa-unit-3-greedy methodhodcsencet

Greedy AlgorithmsAmrinder Arora

Matrix mult class-17Kumar

Viewers also liked (19)

Randomized Algorithms in Linear Algebra & the Column Subset Selection ProblemWei Xue

Chap08algMunkhchimeg

Elements of dynamic programmingTafhim Islam

Class warshal2Debarati Das

This document discusses Warshall's algorithm for finding the transitive closure of a graph using dynamic programming. It begins with an introduction to transitive closure and how it relates to Facebook vs Google+ graph types. It then provides an explanation of Warshall's algorithm, including a visitation example and weighted example. It analyzes the time and space complexity of Warshall's algorithm as O(n3) and O(n2) respectively. It concludes with applications of Warshall's algorithm such as shortest paths and bipartite graph checking.

Mathematical analysis of Graph and Huff amn codingDr Anjan Krishnamurthy

This document summarizes and analyzes algorithms for minimum spanning tree problems and Huffman coding. It discusses Prim's and Kruskal's algorithms for finding minimum spanning trees in graphs, and Huffman's algorithm for data compression. For each algorithm, it covers the key steps, proofs of correctness, and mathematical analysis of time complexity. It also provides context on problems addressed by minimum spanning trees and motivation for using Huffman coding in data compression.

Introduction to-sqlBG Java EE Course

Dynamic programmingMaher Alshammari

Solving The Shortest Path Tour ProblemNozir Shokirov

The Shortest Path Tour Problem is an extension to the normal Shortest Path Problem and appeared in the scientific literature in Bertsekas's dynamic programming and optimal control book in 2005, for the first time. This paper gives a description of the problem, two algorithms to solve it. Results to the numeric experimentation are given in terms of graphs. Finally, conclusion and discussions are made.

Average case Analysis of QuicksortRajendran

21 backtrackingAparup Behera

The document discusses the problem solving technique of backtracking. Backtracking involves making a series of decisions with limited information, where each decision leads to further choices. It explores potential solutions systematically by trying choices and abandoning ("backtracking") from choices that do not lead to solutions. Examples where backtracking can be applied include solving mazes, map coloring problems, and puzzles. The key aspects of backtracking are exploring potential solutions through recursion or looping, checking if a partial solution can be completed at each choice, and abandoning incomplete solutions that cannot be completed.

5.5 back trackKrish_ver2

The document discusses various backtracking algorithms and problems. It begins with an overview of backtracking as a general algorithm design technique for problems that involve traversing decision trees and exploring partial solutions. It then provides examples of specific problems that can be solved using backtracking, including the N-Queens problem, map coloring problem, and Hamiltonian circuits problem. It also discusses common terminology and concepts in backtracking algorithms like state space trees, pruning nonpromising nodes, and backtracking when partial solutions are determined to not lead to complete solutions.

Subset sum problem Dynamic and Brute Force ApprochIjlal Ijlal

The document discusses the subset sum problem and approaches to solve it. It begins by defining the problem and providing an example. It then analyzes the brute force approach of checking all possible subsets and calculates its exponential time complexity. The document introduces dynamic programming as an efficient alternative, providing pseudocode for a dynamic programming algorithm that solves the problem in polynomial time by storing previously computed solutions. It concludes by discussing applications of similar problems in traveling salesperson and drug discovery.

Huffman codesNargis Ehsan

Huffman codes are a technique for lossless data compression that assigns variable-length binary codes to characters, with more frequent characters having shorter codes. The algorithm builds a frequency table of characters then constructs a binary tree to determine optimal codes. Characters are assigned codes based on their path from the root, with left branches representing 0 and right 1. Both encoder and decoder use this tree to translate between binary codes and characters. The tree guarantees unique decoding and optimal compression.

Covering (Rules-based) AlgorithmZHAO Sam

BacktrackingVikas Sharma

Lect6 csptrivedidr

Constraint satisfaction problems (CSPs) define states as assignments of variables to values from their domains, with constraints specifying allowable combinations. Backtracking search assigns one variable at a time using depth-first search. Improved heuristics like most-constrained variable selection and least-constraining value choice help. Forward checking and constraint propagation techniques like arc consistency detect inconsistencies earlier than backtracking alone. Local search methods like min-conflicts hill-climbing can also solve CSPs by allowing constraint violations and minimizing them.

BacktrackingSally Salem

Backtracking is used to systematically search for solutions to problems by trying possibilities and abandoning ("backtracking") partial candidate solutions that fail to satisfy constraints. Examples discussed include the rat in a maze problem, the traveling salesperson problem, container loading, finding the maximum clique in a graph, and board permutation problems. Backtracking algorithms traverse the search space depth-first and use pruning techniques like discarding partial solutions that cannot lead to better complete solutions than those already found.

Queue- 8 QueenHa Ninh

This document discusses data structures and algorithms related to queues. It defines queues as first-in first-out (FIFO) linear lists and describes common queue operations like offer(), poll(), peek(), and isEmpty(). Implementations of queues using linked lists and circular arrays are presented. Applications of queues include accessing shared resources and serving as components of other data structures. The document concludes by explaining the eight queens puzzle and presenting an algorithm to solve it using backtracking.

(Binary tree)almario1988

The document discusses binary trees and various operations on them. It defines what a binary tree is composed of (nodes with values and pointers to left and right children). It describes tree traversals like preorder, inorder and postorder that output the nodes in different orders. It explains two common search strategies - depth-first search (DFS) and breadth-first search (BFS) - and provides examples of how they traverse a sample tree. It also briefly discusses operations like finding the minimum/maximum element, inserting a new element, and deleting an existing element from the binary search tree.

Randomized Algorithms in Linear Algebra & the Column Subset Selection ProblemWei Xue

Chap08algMunkhchimeg

Elements of dynamic programmingTafhim Islam

Class warshal2Debarati Das

Mathematical analysis of Graph and Huff amn codingDr Anjan Krishnamurthy

Introduction to-sqlBG Java EE Course

Dynamic programmingMaher Alshammari

Solving The Shortest Path Tour ProblemNozir Shokirov

Average case Analysis of QuicksortRajendran

21 backtrackingAparup Behera

5.5 back trackKrish_ver2

Subset sum problem Dynamic and Brute Force ApprochIjlal Ijlal

Huffman codesNargis Ehsan

Covering (Rules-based) AlgorithmZHAO Sam

BacktrackingVikas Sharma

Lect6 csptrivedidr

BacktrackingSally Salem

Queue- 8 QueenHa Ninh

(Binary tree)almario1988

Similar to Dynamic programming in Algorithm Analysis (20)

lecture 23sajinsc

The document discusses dynamic programming and amortized analysis. It reviews how dynamic tables use amortized analysis to achieve an overall cost of O(1) per insertion by occasionally doubling the table size and reinserting all elements. This results in a worst case cost of O(n) for a single insertion but averages to O(1) over many insertions. It also discusses using an accounting method with a $3 charge per insertion to pay for future table resizes, achieving an amortized cost of O(1) per operation. Finally, it introduces dynamic programming and uses the longest common subsequence problem to illustrate how it breaks problems into optimal subrecurring subproblems.

AA_Unit 1_part-I.pptxswapnilslide2019

The document provides an overview of advanced algorithms, including: 1) Definitions of algorithms, importance in computer science, and types like search, sorting, graph, and dynamic programming algorithms. 2) Evaluating efficiency using time and space complexity, with Big O notation describing upper bounds of time complexity. 3) Calculating time complexity based on input size growth rather than runtime. 4) Amortized analysis focusing on sequences of operations rather than each individually, using aggregate, accounting, and potential methods.

Chapter One.pdfabay golla

This document discusses algorithm analysis concepts such as time complexity, space complexity, and big-O notation. It explains how to analyze the complexity of algorithms using techniques like analyzing loops, nested loops, and sequences of statements. Common complexities like O(1), O(n), and O(n^2) are explained. Recurrence relations and solving them using iteration methods are also covered. The document aims to teach how to measure and classify the computational efficiency of algorithms.

Alg_Wks1_2.pdflklokjbhvkv jv .v.vk.hk kv h/k227567

complexity analysis.pdfpasinduneshan

This document discusses complexity analysis of algorithms. It defines an algorithm and lists properties like being correct, unambiguous, terminating, and simple. It describes common algorithm design techniques like divide and conquer, dynamic programming, greedy method, and backtracking. It compares divide and conquer with dynamic programming. It discusses algorithm analysis in terms of time and space complexity to predict resource usage and compare algorithms. It introduces asymptotic notations like Big-O notation to describe upper bounds of algorithms as input size increases.

Hash tableRajendran

This document discusses hashing techniques for implementing symbol tables. It begins by reviewing the motivation for symbol tables in compilers and describing the basic operations of search, insertion and deletion that a hash table aims to support efficiently. It then discusses direct addressing and its limitations when key ranges are large. The concept of a hash function is introduced to map keys to a smaller range to enable direct addressing. Collision resolution techniques of chaining and open addressing are covered. Analysis of expected costs for different operations on chaining hash tables is provided. Various hash functions are described including division and multiplication methods, and the importance of choosing a hash function to distribute keys uniformly is discussed. The document concludes by mentioning universal hashing as a technique to randomize the hash function

AA_Unit 1_part-II.pdfswapnilslide2019

This document discusses amortized analysis techniques for analyzing the performance of dynamic hash tables that grow in size. It presents an example of a dynamic hash table that doubles in size when it overflows. It then analyzes this using three different amortized analysis methods: aggregate analysis, accounting method, and potential method. The potential method defines a potential function related to the size of the table to assign amortized costs that bound the actual costs while showing the amortized cost per operation is small.

DAA-Unit1.pptxNishaS88

This document discusses algorithms and their analysis. It begins with definitions of algorithms and their characteristics. Different methods for specifying algorithms are described, including pseudocode. The goal of algorithm analysis is introduced as comparing algorithms based on running time and other factors. Common algorithm analysis methods like worst-case, best-case, and average-case are defined. Big-O notation and time/space complexity are explained. Common algorithm design strategies like divide-and-conquer and randomized algorithms are summarized. Specific algorithms like repeated element detection and primality testing are mentioned.

lecture3.pptlecture3 data structures ppttSyedAliShahid3

Lecture 3 insertion sort and complexity analysisjayavignesh86

This document discusses algorithms and insertion sort. It begins by defining time complexity as the amount of computer time required by an algorithm to complete. Time complexity is measured by the number of basic operations like comparisons, not in physical time units. The document then discusses how to calculate time complexity by counting the number of times loops and statements are executed. It provides examples of calculating time complexities of O(n) for a simple for loop and O(n^2) for a nested for loop. Finally, it introduces insertion sort and divide-and-conquer algorithms.

Matt Purkeypile's Doctoral Dissertation Defense Slidesmpurkeypile

This document summarizes a doctoral dissertation defense presentation on Cove, a practical quantum computer programming framework. The presentation introduces quantum computing concepts, provides a simple example of Shor's factoring algorithm, discusses challenges with programming quantum computers, and outlines Cove's object-oriented approach which aims to address usability issues with existing solutions by programming against interfaces rather than specific implementations. Cove includes a simulated quantum computer for executing code and provides extensibility, documentation, and handles classical computation through the host language (C#).

Lec1.pptxAsadbekIbragimov1

The document outlines an algorithm design and analysis course taught over 12 weeks. It will cover topics like algorithm analysis, data structures, sorting, trees, hashing, and graph algorithms. Students will complete a presentation on either greedy algorithms, divide and conquer, randomized algorithms, or backtracking algorithms. The reading material is a textbook on data structures and algorithms. Examples are provided to illustrate running time analysis and the use of recursion to solve problems like printing out a positive integer digit-by-digit.

Control System Homework HelpMatlab Assignment Experts

I am Kepha M. I am a Control System Assignment Expert at matlabassignmentexperts.com. I hold a Ph.D. in Matlab, McGill University, Canada. I have been helping students with their homework for the past 8 years. I solve assignments related to Control Systems. Visit matlabassignmentexperts.com or email [email protected]. You can also call on +1 678 648 4277 for any assistance with Control System Assignments.

01 - Analysis of Efficiency.pptxIshtiaq Rasool Khan

This document discusses analyzing the time efficiency of algorithms. It covers: 1. Defining key terms like algorithms, input size, basic operations, worst/best/average cases. 2. Methods for analyzing efficiency including determining order of growth and asymptotic notation like O, Ω, Θ. 3. Examples of analyzing non-recursive algorithms like maximum element (O(n)), matrix multiplication (O(n^3)), and counting binary digits (O(log n)). In summary, it provides foundations for analyzing the time complexity of algorithms using order of growth and asymptotic notation to evaluate efficiency classes like constant, logarithmic, linear, and exponential.

AlgorithmsDevMix

The document discusses various topics related to computer programming including: - What a program is and how it is made up of instructions for input, processing, and output. - Common programming tools and concepts such as algorithms, data structures, programming methodologies, compilers, and operating systems. - Specific data structures like arrays, linked lists, stacks, queues, and trees. - Algorithm efficiency analysis including big O notation and analyzing best, average, and worst case running times. - Problem solving approaches like formulating specifications, designing strategies, and implementing solutions recursively or iteratively.

Algorithm And analysis Lecture 03& 04-time complexity.Tariq Khan

This document discusses algorithm efficiency and complexity analysis. It defines key terms like algorithms, asymptotic complexity, Big O notation, and different complexity classes. It provides examples of analyzing time complexity for different algorithms like loops, nested loops, and recursive functions. The document explains that Big O notation allows analyzing algorithms independent of machine or input by focusing on the highest order term as the problem size increases. Overall, the document introduces methods for measuring an algorithm's efficiency and analyzing its time and space complexity asymptotically.

algorithmanalysis and effciency.pptxChSreenivasuluReddy

The document discusses algorithm analysis and determining the efficiency of algorithms. It introduces key concepts such as: - Algorithms must be correct and efficient to solve problems. - The time and space complexity of algorithms is analyzed to compare efficiencies. Common growth rates include constant, logarithmic, linear, quadratic, and exponential time. - The asymptotic worst-case time complexity of an algorithm (its "order") is expressed using Big O notation, such as O(n) for linear time. Higher order terms indicate slower growth.

2 chapter2 algorithm_analysispart1SSE_AndyLi

This document discusses algorithm analysis and asymptotic notation. It defines common asymptotic notations like O(N), Ω(N), and Θ(N) and provides examples of analyzing simple algorithms and determining their time complexities. The document also outlines general rules for analyzing algorithms with loops, nested loops, consecutive statements, and recursion to determine their asymptotic running times.

Design & Analysis of Algorithm course .pptxJeevaMCSEKIOT

This document discusses algorithms and their analysis. It defines an algorithm as a well-defined computational procedure that takes inputs and produces outputs. Key characteristics of algorithms include definiteness, finiteness, effectiveness, correctness, simplicity, and unambiguousness. The document discusses two common algorithm design techniques: divide and conquer, which divides a problem into subproblems, and greedy techniques, which make locally optimal choices to find a near-optimal solution. It also covers analyzing algorithms, including asymptotic time and space complexity analysis to determine how resource usage grows with problem size.

Analysis of algoSandeep Bhargava

The document discusses analyzing the efficiency of algorithms. It notes that algorithms can be correct but the best depends on efficiency. Efficiency depends on time and space complexity, where time complexity is the amount of time needed for complete execution and space complexity is the amount of memory required. Different algorithms have different efficiencies that can be analyzed based on how processing time and memory usage increase with larger input sizes.

lecture 23sajinsc

AA_Unit 1_part-I.pptxswapnilslide2019

Chapter One.pdfabay golla

Alg_Wks1_2.pdflklokjbhvkv jv .v.vk.hk kv h/k227567

complexity analysis.pdfpasinduneshan

Hash tableRajendran

AA_Unit 1_part-II.pdfswapnilslide2019

DAA-Unit1.pptxNishaS88

lecture3.pptlecture3 data structures ppttSyedAliShahid3

Lecture 3 insertion sort and complexity analysisjayavignesh86

Matt Purkeypile's Doctoral Dissertation Defense Slidesmpurkeypile

Lec1.pptxAsadbekIbragimov1

Control System Homework HelpMatlab Assignment Experts

01 - Analysis of Efficiency.pptxIshtiaq Rasool Khan

AlgorithmsDevMix

Algorithm And analysis Lecture 03& 04-time complexity.Tariq Khan

algorithmanalysis and effciency.pptxChSreenivasuluReddy

2 chapter2 algorithm_analysispart1SSE_AndyLi

Design & Analysis of Algorithm course .pptxJeevaMCSEKIOT

Analysis of algoSandeep Bhargava

More from Rajendran (20)

Element distinctness lower boundsRajendran

The document provides an overview of a lecture on proving a lower time bound of Ω(n log n) for the element distinctness problem in the decision tree model. It begins by defining the element distinctness problem and stating the lower bound that will be proved. It then discusses interpreting the input sequence as coordinates of an n-dimensional point and restricting points to the unit n-cube. The key claims are that each leaf region is connected, and distinct input points must reach distinct leaves, implying there are at least n! leaves and a time lower bound of n log n.

Scheduling with Startup and Holding CostsRajendran

This document summarizes a lecture on scheduling problems with startup and holding costs. The problem involves scheduling production on a machine over multiple days to meet demand, while minimizing costs. Costs include a startup cost each time the machine is turned on, and a holding cost each day inventory is stored. The lecture defines the problem formally, provides an example, and discusses using dynamic programming to find an optimal schedule efficiently through characterizing subproblems and storing results in a table.

Divide and conquer surfing lower boundsRajendran

The document discusses lower bounds for sorting algorithms. It shows that the worst case and average case lower bounds for sorting are both Ω(n log n). This lower bound is derived by analyzing the minimum depth of balanced binary decision trees required to represent the n! possible permutations of n elements. Several algorithms, including heapsort, are shown to achieve the optimal time complexity of O(n log n), matching this lower bound. Problem transformations are also introduced as a method for proving lower bounds.

Red black treeRajendran

The document discusses red-black trees, which are binary search trees augmented with node colors to guarantee a height of O(log n). It first defines the properties of red-black trees, then proves their height is O(log n), and finally describes insertion and deletion operations. The key points are that nodes can be red or black, insertion can violate properties so recoloring is needed, and rotations are used to restructure the tree during insertion and deletion while maintaining the red-black properties.

Medians and order statisticsRajendran

The document discusses algorithms for finding order statistics like the median in a list of numbers. It presents a randomized selection algorithm that finds the ith smallest element in expected linear time O(n) by using a randomized partition like in quicksort. It also describes a deterministic selection algorithm that finds the ith element in worst-case linear time O(n) by partitioning the list around the median of medians. Finding the median can then be used to sort in linear time by recursively finding order statistics.

Proof master theoremRajendran

1) The document provides the proof of the Master Theorem for analyzing divide-and-conquer recurrences. 2) It introduces key lemmas used in the proof, including bounding the contribution of subproblem sizes. 3) The proof considers three cases depending on how the work at each level relates to the decrease in problem size, showing the recurrence has a runtime of O(nlogba), O(nklogn), or O(nk) respectively.

Recursion tree methodRajendran

- Recurrences describe functions in terms of their values on smaller inputs and arise when algorithms contain recursive calls to themselves. - To analyze the running time of recursive algorithms, the recurrence must be solved to find an explicit formula or bound the expression in terms of n. - Examples of recurrences and their solutions are given, including binary search (O(log n)), dividing the input in half at each step (O(n)), and dividing the input in half but examining all items (O(n)). - Methods for solving recurrences include iteration, substitution, and using recursion trees to "guess" the solution.

Recurrence theoremRajendran

The document discusses different methods for analyzing recursive functions, including: 1. The recursion-tree method, which represents each subproblem as a node with costs summed at each level and total. This is suitable for divide-and-conquer recurrences. 2. An example of using the recursion-tree method to solve T(n)=3T(n/4)+Θ(n^2), showing the tree has height log4n, Θ(nlog43) leaf nodes each costing T(1), and total cost O(n^2). 3. Another example of T(n)=T(n/3)+T(2n/3)+O(n

Master method Rajendran

This document discusses recurrences and algorithms analysis. It covers: 1. Recurrences arise when an algorithm contains recursive calls to itself. The running time is described by a recurrence relation. 2. Examples of recurrence relations are given for different types of recursive algorithms. 3. The binary search algorithm is presented as an example recursive algorithm and its recurrence relation is derived.

Master method theoremRajendran

Hash tablesRajendran

The document discusses hash tables and how they can be used to implement dictionaries. Hash tables map keys to table slots using a hash function in order to store and retrieve items efficiently. Collisions may occur when multiple keys hash to the same slot. Chaining is described as a method to handle collisions by storing colliding items in linked lists attached to table slots. Analysis shows that with simple uniform hashing, dictionary operations like search, insert and delete take expected O(1) time on average.

Lower boundRajendran

This chapter discusses limitations on algorithmic power and methods for establishing lower bounds on algorithms. It introduces lower bounds as estimates of the minimum amount of work needed to solve a problem. Several methods are presented for establishing lower bounds, including trivial lower bounds based on input/output sizes, decision trees to model comparisons, adversary arguments, and reducing one problem to another with a known lower bound. Examples are given for sorting, searching, and matrix multiplication.

Master method theoremRajendran

Greedy algorithmsRajendran

This document discusses greedy algorithms and dynamic programming techniques for solving optimization problems. It covers the activity selection problem, which can be solved greedily by always selecting the shortest remaining activity. It also discusses the knapsack problem and how the fractional version can be solved greedily while the 0-1 version requires dynamic programming due to its optimal substructure but non-greedy nature. Dynamic programming builds up solutions by combining optimal solutions to overlapping subproblems.

Longest common subsequences in Algorithm AnalysisRajendran

The document discusses dynamic programming and the longest common subsequence (LCS) problem. It provides an example of using dynamic programming to find the LCS of two strings "ABCB" and "BDCAB" in multiple steps. The algorithm builds up the solution by filling a 2D array c[m,n] where m and n are the lengths of the two strings. Each entry c[i,j] represents the length of the LCS of the prefixes of length i and j of the two strings. The running time is O(mn).

Np completenessRajendran

1) NP-Completeness refers to problems that are in NP (can be verified in polynomial time) and are as hard as any problem in NP. 2) The first problem proven to be NP-Complete was the Circuit Satisfiability problem, which asks whether there exists an input assignment that makes a Boolean circuit output 1. 3) To prove a problem P is NP-Complete, it must be shown that P is in NP and that any problem in NP can be reduced to P in polynomial time. This establishes P as at least as hard as any problem in NP.

computer languagesRajendran

The document discusses the differences between low-level machine code used by CPUs and high-level computer languages used by programmers. It explains that programmers write source code in high-level languages, which are then compiled into machine code through a compiler or interpreted line-by-line using an interpreter. Compiled code tends to run faster while interpreted languages typically have more programmer-friendly features. Modern dynamic languages often use a just-in-time compiler to bridge performance gaps.

proving non-computabilityRajendran

This document discusses how to prove that a problem is not computable by showing that no algorithm exists that can solve the problem. It specifically discusses using a technique called reduction proofs, where showing that a solution to one problem could be used to solve a known non-computable problem like the Halting Problem proves that the first problem is also non-computable. As an example, it proves the Prints-Three Problem is non-computable by showing how a solution to it could determine if any program halts, solving the Halting Problem.

the halting_problemRajendran

The document discusses the halting problem, which asks if there are problems for which no algorithm exists. Alan Turing proved that non-computable problems exist by introducing the halting problem - determining if a given program will ever finish running. The document shows that no procedure can solve the halting problem by considering a paradoxical program: if it says the program halts, it leads to a contradiction, and if it says the program doesn't halt, it also leads to a contradiction. This proves the halting problem is non-computable, as any procedure to solve it would have to either give the wrong answer or not terminate. A formal model of computation is needed to give a rigorous proof.

universalityRajendran

Turing Machines are a model of computation that can simulate any algorithm. A Universal Turing Machine can simulate any other Turing Machine. This means that a Universal Turing Machine can perform any computation. Any programming language that can simulate a Universal Turing Machine is considered a universal programming language, as it can perform any computation. Scheme is an example of a universal programming language since it is possible to write a Scheme program that simulates a Universal Turing Machine.

Element distinctness lower boundsRajendran

Scheduling with Startup and Holding CostsRajendran

Divide and conquer surfing lower boundsRajendran

Red black treeRajendran

Medians and order statisticsRajendran

Proof master theoremRajendran

Recursion tree methodRajendran

Recurrence theoremRajendran

Master method Rajendran

Master method theoremRajendran

Hash tablesRajendran

Lower boundRajendran

Master method theoremRajendran

Greedy algorithmsRajendran

Longest common subsequences in Algorithm AnalysisRajendran

Np completenessRajendran

computer languagesRajendran

proving non-computabilityRajendran

the halting_problemRajendran

universalityRajendran

Recently uploaded (20)

Unit- 4 Biostatistics & Research Methodology.pdfKRUTIKA CHANNE

Blocking and confounding (when a third variable, or confounder, influences both the exposure and the outcome) system for Two-level factorials (a type of experimental design where each factor (independent variable) is investigated at only two levels, typically denoted as "high" and "low" or "+1" and "-1") Regression modeling (statistical model that estimates the relationship between one dependent variable and one or more independent variables using a line): Hypothesis testing in Simple and Multiple regression models Introduction to Practical components of Industrial and Clinical Trials Problems: Statistical Analysis Using Excel, SPSS, MINITAB®️, DESIGN OF EXPERIMENTS, R - Online Statistical Software to Industrial and Clinical trial approach

TV Shows and web-series quiz | QUIZ CLUB OF PSGCAS | 13TH MARCH 2025Quiz Club of PSG College of Arts & Science

Different pricelists for different shops in odoo Point of Sale in Odoo 17Celine George

Respiratory System , Urinary SystemRushiMandali

Human Anatomy and Physiology II Unit 3 B pharm Sem 2 Respiratory system Anatomy of respiratory system with special reference to anatomy of lungs, mechanism of respiration, regulation of respiration Lung Volumes and capacities transport of respiratory gases, artificial respiration, and resuscitation methods Urinary system Anatomy of urinary tract with special reference to anatomy of kidney and nephrons, functions of kidney and urinary tract, physiology of urine formation, micturition reflex and role of kidneys in acid base balance, role of RAS in kidney and disorders of kidney

Trends Spotting Strategic foresight for tomorrow’s education systems - Debora...EduSkills OECD

Deborah Nusche, Senior Analyst, OECD presents at the OECD webinar 'Trends Spotting: Strategic foresight for tomorrow’s education systems' on 5 June 2025. You can check out the webinar on the website https://oecdedutoday.com/webinars/ Other speakers included: Deborah Nusche, Senior Analyst, OECD Sophie Howe, Future Governance Adviser at the School of International Futures, first Future Generations Commissioner for Wales (2016-2023) Davina Marie, Interdisciplinary Lead, Queens College London Thomas Jørgensen, Director for Policy Coordination and Foresight at European University Association

Adam Grant: Transforming Work Culture Through Organizational PsychologyPrachi Shah

This presentation explores the groundbreaking work of Adam Grant, renowned organizational psychologist and bestselling author. It highlights his key theories on giving, motivation, leadership, and workplace dynamics that have revolutionized how organizations think about productivity, collaboration, and employee well-being. Ideal for students, HR professionals, and leadership enthusiasts, this deck includes insights from his major works like Give and Take, Originals, and Think Again, along with interactive elements for enhanced engagement.

LDMMIA Reiki Yoga Next Week Grad UpdatesLDM & Mia eStudios

A short update and next week. I am writing both Session 9 and Orientation S1. As a Guest Student, You are now upgraded to Grad Level. See Uploads for “Student Checkin” & “S8”. Thx. Thank you for attending our workshops. If you are new, do welcome. Grad Students: I am planning a Reiki-Yoga Master Course (As a package). I’m Fusing both together. This will include the foundation of each practice. Our Free Workshops can be used with any Reiki Yoga training package. Traditional Reiki does host rules and ethics. Its silent and within the JP Culture/Area/Training/Word of Mouth. It allows remote healing but there’s limits As practitioners and masters. We are not allowed to share certain secrets/tools. Some content is designed only for “Masters”. Some yoga are similar like the Kriya Yoga-Church (Vowed Lessons). We will review both Reiki and Yoga (Master tools) in the Course upcoming. Session Practice, For Reference: Before starting a session, Make sure to check your environment. Nothing stressful. Later, You can decorate a space as well. Check the comfort level, any needed resources (Yoga/Reiki/Spa Props), or Meditation Asst? Props can be oils, sage, incense, candles, crystals, pillows, blankets, yoga mat, any theme applies. Select your comfort Pose. This can be standing, sitting, laying down, or a combination. Monitor your breath. You can add exercises. Add any mantras or affirmations. This does aid mind and spirit. It helps you to focus. Also you can set intentions using a candle. The Yoga-key is balancing mind, body, and spirit. Finally, The Duration can be long or short. Its a good session base for any style. Next Week’s Focus: A continuation of Intuition Development. We will review the Chakra System - Our temple. A misguided, misused situation lol. This will also serve Attunement later. For Sponsor, General updates, & Donations: Please visit: https://ldmchapels.weebly.com

Hemiptera & Neuroptera: Insect Diversity.pptxArshad Shaikh

*Order Hemiptera:* Hemiptera, commonly known as true bugs, is a large and diverse order of insects that includes cicadas, aphids, leafhoppers, and shield bugs. Characterized by their piercing-sucking mouthparts, Hemiptera feed on plant sap, other insects, or small animals. Many species are significant pests, while others are beneficial predators. *Order Neuroptera:* Neuroptera, also known as net-winged insects, is an order of insects that includes lacewings, antlions, and owlflies. Characterized by their delicate, net-like wing venation and large, often prominent eyes, Neuroptera are predators that feed on other insects, playing an important role in biological control. Many species have aquatic larvae, adding to their ecological diversity.

Capitol Doctoral Presentation -June 2025.pptxCapitolTechU

How to Manage Upselling of Subscriptions in Odoo 18Celine George

Pfeiffer "Secrets to Changing Behavior in Scholarly Communication: A 2025 NIS...National Information Standards Organization (NISO)

Exploring Ocean Floor Features for Middle SchoolMarie

Final Sketch Designs for poster production.pptxbobby205207

Rai dyansty Chach or Brahamn dynasty, History of Dahir History of Sindh NEP.pptxDr. Ravi Shankar Arya Mahila P. G. College, Banaras Hindu University, Varanasi, India.

This presentation has been made keeping in mind the students of undergraduate and postgraduate level. To keep the facts in a natural form and to display the material in more detail, the help of various books, websites and online medium has been taken. Whatever medium the material or facts have been taken from, an attempt has been made by the presenter to give their reference at the end. In the seventh century, the rule of Sindh state was in the hands of Rai dynasty. We know the names of five kings of this dynasty- Rai Divji, Rai Singhras, Rai Sahasi, Rai Sihras II and Rai Sahasi II. During the time of Rai Sihras II, Nimruz of Persia attacked Sindh and killed him. After the return of the Persians, Rai Sahasi II became the king. After killing him, one of his Brahmin ministers named Chach took over the throne. He married the widow of Rai Sahasi and became the ruler of entire Sindh by suppressing the rebellions of the governors.

Black and White Illustrative Group Project Presentation.pdf (1).pdfAnnasofiaUrsini

Analysis of Quantitative Data Parametric and non-parametric tests.pptxShrutidhara2

This presentation covers the following points-- Parametric Tests • Testing the Significance of the Difference between Means • Analysis of Variance (ANOVA) - One way and Two way • Analysis of Co-variance (One-way)  Non-Parametric Tests: • Chi-Square test • Sign test • Median test • Sum of Rank test • Mann-Whitney U-test Moreover, it includes a comparison of parametric and non-parametric tests, a comparison of one-way ANOVA, two-way ANOVA, and one-way ANCOVA.

How to Create a Rainbow Man Effect in Odoo 18Celine George

Gibson "Secrets to Changing Behaviour in Scholarly Communication: A 2025 NISO...National Information Standards Organization (NISO)

Artificial intelligence Presented by JM.jmansha170

AI (Artificial Intelligence) : "AI is the ability of machines to mimic human intelligence, such as learning, decision-making, and problem-solving." Important Points about AI: 1. Learning – AI can learn from data (Machine Learning). 2. Automation – It helps automate repetitive tasks. 3. Decision Making – AI can analyze and make decisions faster than humans. 4. Natural Language Processing (NLP) – AI can understand and generate human language. 5. Vision & Recognition – AI can recognize images, faces, and patterns. 6. Used In – Healthcare, finance, robotics, education, and more. Owner By: Name : Junaid Mansha Work : Web Developer and Graphics Designer Contact us : +92 322 2291672 Email : [email protected]

IDF 30min presentation - December 2, 2024.pptxArneeAgligar

Unit- 4 Biostatistics & Research Methodology.pdfKRUTIKA CHANNE

TV Shows and web-series quiz | QUIZ CLUB OF PSGCAS | 13TH MARCH 2025Quiz Club of PSG College of Arts & Science

Different pricelists for different shops in odoo Point of Sale in Odoo 17Celine George

Respiratory System , Urinary SystemRushiMandali

Trends Spotting Strategic foresight for tomorrow’s education systems - Debora...EduSkills OECD

Adam Grant: Transforming Work Culture Through Organizational PsychologyPrachi Shah

LDMMIA Reiki Yoga Next Week Grad UpdatesLDM & Mia eStudios

Hemiptera & Neuroptera: Insect Diversity.pptxArshad Shaikh

Capitol Doctoral Presentation -June 2025.pptxCapitolTechU

How to Manage Upselling of Subscriptions in Odoo 18Celine George

Pfeiffer "Secrets to Changing Behavior in Scholarly Communication: A 2025 NIS...National Information Standards Organization (NISO)

Exploring Ocean Floor Features for Middle SchoolMarie

Final Sketch Designs for poster production.pptxbobby205207

Rai dyansty Chach or Brahamn dynasty, History of Dahir History of Sindh NEP.pptxDr. Ravi Shankar Arya Mahila P. G. College, Banaras Hindu University, Varanasi, India.

Black and White Illustrative Group Project Presentation.pdf (1).pdfAnnasofiaUrsini

Analysis of Quantitative Data Parametric and non-parametric tests.pptxShrutidhara2

How to Create a Rainbow Man Effect in Odoo 18Celine George

Gibson "Secrets to Changing Behaviour in Scholarly Communication: A 2025 NISO...National Information Standards Organization (NISO)

Artificial intelligence Presented by JM.jmansha170

IDF 30min presentation - December 2, 2024.pptxArneeAgligar

Dynamic programming in Algorithm Analysis

1. David Luebke 1 CS 332: Algorithms Dynamic Programming

2. David Luebke 2 Review: Amortized Analysis ● To illustrate amortized analysis we examined dynamic tables 1. Init table size m = 1 2. Insert elements until number n > m 3. Generate new table of size 2m 4. Reinsert old elements into new table 5. (back to step 2) ● What is the worst-case cost of an insert? ● What is the amortized cost of an insert?

3. David Luebke 3 Review: Analysis Of Dynamic Tables ● Let ci = cost of ith insert ● ci = i if i-1 is exact power of 2, 1 otherwise ● Example: ■ Operation Table Size Cost Insert(1) 1 1 1 Insert(2) 2 1 + 1 2 Insert(3) 4 1 + 2 Insert(4) 4 1 Insert(5) 8 1 + 4 Insert(6) 8 1 Insert(7) 8 1 Insert(8) 8 1 Insert(9) 16 1 + 8 1 2 3 4 5 6 7 8 9

4. David Luebke 4 Review: Aggregate Analysis ● n Insert() operations cost ● Average cost of operation = (total cost)/(# operations) < 3 ● Asymptotically, then, a dynamic table costs the same as a fixed-size table ■ Both O(1) per Insert operation nnnnc n j j n i i 3)12(2 lg 01 <−+=+≤ ∑∑ ==

5. David Luebke 5 Review: Accounting Analysis ● Charge each operation $3 amortized cost ■ Use $1 to perform immediate Insert() ■ Store $2 ● When table doubles ■ $1 reinserts old item, $1 reinserts another old item ■ We’ve paid these costs up front with the last n/2 Insert()s ● Upshot: O(1) amortized cost per operation

6. David Luebke 6 Review: Accounting Analysis ● Suppose must support insert & delete, table should contract as well as expand ■ Table overflows ⇒ double it (as before) ■ Table < 1/4 full ⇒ halve it ■ Charge $3 for Insert (as before) ■ Charge $2 for Delete ○ Store extra $1 in emptied slot ○ Use later to pay to copy remaining items to new table when shrinking table ● What if we halve size when table < 1/8 full?

7. David Luebke 7 Dynamic Programming ● Another strategy for designing algorithms is dynamic programming ■ A metatechnique, not an algorithm (like divide & conquer) ■ The word “programming” is historical and predates computer programming ● Use when problem breaks down into recurring small subproblems

8. David Luebke 8 Dynamic Programming Example: Longest Common Subsequence ● Longest common subsequence (LCS) problem: ■ Given two sequences x[1..m] and y[1..n], find the longest subsequence which occurs in both ■ Ex: x = {A B C B D A B }, y = {B D C A B A} ■ {B C} and {A A} are both subsequences of both ○ What is the LCS? ■ Brute-force algorithm: For every subsequence of x, check if it’s a subsequence of y ○ How many subsequences of x are there? ○ What will be the running time of the brute-force alg?

9. David Luebke 9 LCS Algorithm ● Brute-force algorithm: 2m subsequences of x to check against n elements of y: O(n 2m ) ● We can do better: for now, let’s only worry about the problem of finding the length of LCS ■ When finished we will see how to backtrack from this solution back to the actual LCS ● Notice LCS problem has optimal substructure ■ Subproblems: LCS of pairs of prefixes of x and y

10. David Luebke 10 Finding LCS Length ● Define c[i,j] to be the length of the LCS of x[1..i] and y[1..j] ■ What is the length of LCS of x and y? ● Theorem: ● What is this really saying?    −− =+−− = otherwise]),1[],1,[max( ],[][if1]1,1[ ],[ jicjic jyixjic jic

11. David Luebke 11 The End

Dynamic programming in Algorithm Analysis

Recommended

More Related Content

What's hot (20)

Viewers also liked (19)

Similar to Dynamic programming in Algorithm Analysis (20)

More from Rajendran (20)

Recently uploaded (20)

Dynamic programming in Algorithm Analysis