Activity selection problem
•Download as PPTX, PDF•
0 likes•1,069 views
This document describes an algorithm called the top-down greedy algorithm to solve the activity-selection problem of scheduling non-overlapping activities that have starting and finishing times. The algorithm recursively selects the activity with the earliest finishing time from the remaining activities to build up the maximum set of non-conflicting activities. It takes the starting and finishing times as inputs, starts selecting from activity i, and recursively calls itself to select from the remaining activities until no more can be added without conflicting.
Report
Share
Report
Share
Recommended
Activity selection problem
A greedy algorithm is a problem-solving technique that follows the problem-solving heuristic of making locally optimal choices at each step to find a global optimum. While this may find an optimal solution, it does not guarantee to do so as it does not consider the overall problem. The document discusses applying a greedy algorithm to solve the activity selection problem by always selecting the next activity that finishes earliest without conflicting with previously selected activities. It provides recursive and iterative implementations of the greedy algorithm to solve this problem in O(n log n) time by first sorting activities by finish time.
Recursion
This document discusses recursion in programming. It defines recursion as a procedure that calls itself, with different parameters each time. It explains the key components of a recursive method including base cases and recursive calls. It provides examples of different types of recursion like single/multiple and direct/indirect recursion. Examples of recursively defined sequences and functions like factorials and Fibonacci series are given. Contact details are provided at the end.
Fractional Knapsack Problem
This document discusses the greedy algorithm approach and the knapsack problem. It defines greedy algorithms as choosing locally optimal solutions at each step in hopes of reaching a global optimum. The knapsack problem is described as packing items into a knapsack to maximize total value without exceeding weight capacity. An optimal knapsack algorithm is presented that sorts by value-to-weight ratio and fills highest ratios first. An example applies this to maximize profit of 440 by selecting full quantities of items B and A, and half of item C for a knapsack with capacity of 60.
Primality
A Primality test is an algorithm for determining whether an input number is Prime. Among other fields of mathematics, it is used for Cryptography. Factorization is thought to be a computationally difficult problem, whereas primality testing is comparatively easy (its running time is polynomial in the size of the input).
Elements of Dynamic Programming
Discussed Elements of Dynamic Programming, covered all the points from Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein,‖
Introduction to Algorithms‖, Third Edition, Prentice-Hall, 2011.
Matrix chain multiplication
Dynamic Programming is a technique for algorithm design.
It is a tabular method in which it uses divide-and-conquer to solve problems.
Mathematical Analysis of Recursive Algorithm.
Guide line of Mathematically analysis of Recursive algorithm with example.
using forward and backsword substitution method.
Stressen's matrix multiplication
Strassen's algorithm improves on the basic matrix multiplication algorithm which runs in O(N3) time. It achieves this by dividing the matrices into sub-matrices and performing 7 multiplications and 18 additions on the sub-matrices, rather than the 8 multiplications of the basic algorithm. This results in a runtime of O(N2.81) using divide and conquer, providing an asymptotic improvement over the basic O(N3) algorithm.
Recommended
Activity selection problem
A greedy algorithm is a problem-solving technique that follows the problem-solving heuristic of making locally optimal choices at each step to find a global optimum. While this may find an optimal solution, it does not guarantee to do so as it does not consider the overall problem. The document discusses applying a greedy algorithm to solve the activity selection problem by always selecting the next activity that finishes earliest without conflicting with previously selected activities. It provides recursive and iterative implementations of the greedy algorithm to solve this problem in O(n log n) time by first sorting activities by finish time.
Recursion
This document discusses recursion in programming. It defines recursion as a procedure that calls itself, with different parameters each time. It explains the key components of a recursive method including base cases and recursive calls. It provides examples of different types of recursion like single/multiple and direct/indirect recursion. Examples of recursively defined sequences and functions like factorials and Fibonacci series are given. Contact details are provided at the end.
Fractional Knapsack Problem
This document discusses the greedy algorithm approach and the knapsack problem. It defines greedy algorithms as choosing locally optimal solutions at each step in hopes of reaching a global optimum. The knapsack problem is described as packing items into a knapsack to maximize total value without exceeding weight capacity. An optimal knapsack algorithm is presented that sorts by value-to-weight ratio and fills highest ratios first. An example applies this to maximize profit of 440 by selecting full quantities of items B and A, and half of item C for a knapsack with capacity of 60.
Primality
A Primality test is an algorithm for determining whether an input number is Prime. Among other fields of mathematics, it is used for Cryptography. Factorization is thought to be a computationally difficult problem, whereas primality testing is comparatively easy (its running time is polynomial in the size of the input).
Elements of Dynamic Programming
Discussed Elements of Dynamic Programming, covered all the points from Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein,‖
Introduction to Algorithms‖, Third Edition, Prentice-Hall, 2011.
Matrix chain multiplication
Dynamic Programming is a technique for algorithm design.
It is a tabular method in which it uses divide-and-conquer to solve problems.
Mathematical Analysis of Recursive Algorithm.
Guide line of Mathematically analysis of Recursive algorithm with example.
using forward and backsword substitution method.
Stressen's matrix multiplication
Strassen's algorithm improves on the basic matrix multiplication algorithm which runs in O(N3) time. It achieves this by dividing the matrices into sub-matrices and performing 7 multiplications and 18 additions on the sub-matrices, rather than the 8 multiplications of the basic algorithm. This results in a runtime of O(N2.81) using divide and conquer, providing an asymptotic improvement over the basic O(N3) algorithm.
Open addressiing &rehashing,extendiblevhashing
The document discusses various hash table implementation techniques. It describes open addressing hashing which resolves collisions by probing to the next empty cell. Linear probing is discussed as a collision resolution strategy where the next probe is the current index plus one. The document also covers separate chaining hashing which uses linked lists at each index to handle collisions, and double hashing which uses two hash functions to determine probe sequences.
Knapsack problem using greedy approach
In shared PPT we have discussed Knapsack problem using greedy approach and its two types i.e Fractional and 0-1
TOC 3 | Different Operations on DFA
This lecture covers:
1. Regular Language and Regular Operations
2. Closure properties of DFAs
3. Union of 2 DFA machines
4. Intersection of 2 DFA machines
5. Complement of DFA machines
Merge sort algorithm power point presentation
This is a merge sort algorithm presentation. Those are want to learn merge sort by a simple example , he/she can watch to understand easily
Travelling salesman dynamic programming
This document discusses the traveling salesman problem and a dynamic programming approach to solving it. It was presented by Maharaj Dey, a 6th semester CSE student with university roll number 11500117099 for the paper CS-681 (SEMINAR). The document concludes with a thank you.
Greedy method
The document discusses greedy algorithms and how they can be applied to solve optimization problems like the knapsack problem, activity selection problem, and job sequencing problem. It provides examples of greedy algorithms for each problem. A greedy algorithm works by making locally optimal choices at each step in the hope of finding a globally optimal solution. For the knapsack problem, the greedy approach sorts items by profit/weight ratio and fills the knapsack accordingly. For activity selection, it schedules activities based on earliest finish time. For job sequencing, it sorts jobs by profit and schedules the most profitable jobs that meet deadlines.
4.6 halting problem
The document discusses the halting problem and decidability of languages. It defines a decidable language as one where a Turing machine can accept or reject every input string and halt. The halting problem asks whether it is possible to determine if an arbitrary Turing machine will halt on a given input. The document proves the halting problem is undecidable by constructing a machine that contradicts itself, showing no algorithm can correctly determine if all Turing machines halt on all inputs.
Job sequencing with deadline
This document discusses the job sequencing problem, where the goal is to schedule jobs to be completed by their deadlines to maximize total profit. It provides an example problem with 4 jobs, their profits, deadlines, and the optimal solution of scheduling jobs J1 and J2 to earn a total profit of 140.
Algorithm Complexity and Main Concepts
An algorithm is a finite set of instructions to accomplish a predefined task. Performance of an algorithm is measured by its time and space complexity, with common metrics being big O, big Omega, and big Theta notation. Common data structures include arrays, linked lists, stacks, queues, trees and graphs. Key concepts are asymptotic analysis of algorithms, recursion, and analyzing complexity classes like constant, linear, quadratic and logarithmic time.
how to calclute time complexity of algortihm
This document discusses algorithm analysis and complexity. It defines key terms like asymptotic complexity, Big-O notation, and time complexity. It provides examples of analyzing simple algorithms like a sum function to determine their time complexity. Common analyses include looking at loops, nested loops, and sequences of statements. The goal is to classify algorithms according to their complexity, which is important for large inputs and machine-independent. Algorithms are classified based on worst, average, and best case analyses.
01 Knapsack using Dynamic Programming
Intoduction on Dynamic Programming & 0-1 Knapsack problem,
Implementation of 0-1 Knapsack using DP with example, its algorithm & analysis
sum of subset problem using Backtracking
Given a set of non-negative integers, and a value sum, determine if there is a subset of the given set with sum equal to given sum.
Sum of subsets problem by backtracking
We are given n distinct positive numbers (weights)
The objective is to find all combination of weights whose sum is equal to given weights m
State space tree is generated for all the possibilities of the subsets
Generate the tree by keeping weight <= m
Time complexity
Basic info about how to use time complexity and how to get the time of each program to solve the problem.
Recursion - Algorithms and Data Structures
Discuss different types of recursion with examples.
Linear/Binary/Multiple recursion
(Download is recommended to make the animations work)
Unification and Lifting
The document discusses inference rules for quantifiers in first-order logic. It describes the rules of universal instantiation and existential instantiation. Universal instantiation allows inferring sentences by substituting terms for variables, while existential instantiation replaces a variable with a new constant symbol. The document also introduces unification, which finds substitutions to make logical expressions identical. Generalized modus ponens is presented as a rule that lifts modus ponens to first-order logic by using unification to substitute variables.
Unit 2 in daa
1) The document describes the divide-and-conquer algorithm design paradigm. It can be applied to problems where the input can be divided into smaller subproblems, the subproblems can be solved independently, and the solutions combined to solve the original problem.
2) Binary search is provided as an example divide-and-conquer algorithm. It works by recursively dividing the search space in half and only searching the subspace containing the target value.
3) Finding the maximum and minimum elements in an array is also solved using divide-and-conquer. The array is divided into two halves, the max/min found for each subarray, and the overall max/min determined by comparing the subsolutions.
Webinar : P, NP, NP-Hard , NP - Complete problems
Problem | Problem v/s Algorithm v/s Program | Types of Problems | Computational complexity | P class v/s NP class Problems | Polynomial time v/s Exponential time | Deterministic v/s non-deterministic Algorithms | Functions of non-deterministic Algorithms | Non-deterministic searching Algorithm | Non-deterministic sorting Algorithm | NP - Hard and NP - Complete Problems | Reduction | properties of reduction | Satisfiability problem and Algorithm
Longest increasing subsequence
The document describes the longest increasing subsequence problem and a dynamic programming approach to solve it. The problem is to find the length of the longest subsequence of a given array where the elements are in increasing order. The dynamic programming approach uses an array to store the length of the longest increasing subsequence for each element by iterating through the original array. It starts by initializing each value in the array to 1, then iterates to update values where a longer subsequence can be formed by extending a previous subsequence. This takes O(n^2) time.
Asymptotic notation
This document introduces asymptotic notations that are used to describe the time complexity of algorithms. It defines big O, big Omega, and big Theta notations, which describe the limiting behavior of functions. Big O notation provides an asymptotic upper bound, big Omega provides a lower bound, and big Theta provides a tight bound. Examples are given of different asymptotic efficiency classes like constant, logarithmic, linear, quadratic, and exponential time. Properties of asymptotic notations like transitivity, reflexivity, symmetry, and transpose symmetry are also covered.
Activity selection problem class 12
The activity selection problem involves scheduling a shared resource among competing activities. Activities have start and finish times, and only one activity can use the resource at a time. A greedy algorithm finds a maximum set of compatible activities by sorting by finish time and sequentially selecting activities that do not overlap in time. The algorithm runs in O(n log n) time to sort activities and Θ(n) time to select activities, for a total runtime of O(n log n).
Activity selection problem
The document describes an activity selection problem where a set of activities must share a single resource. Each activity has a start and finish time, and activities are mutually compatible if one activity finishes before another starts. The problem is to find the maximum subset of mutually compatible activities. A recursive greedy algorithm is presented that takes the activities sorted by finish time and recursively selects the next compatible activity to build the subset. Pseudocode for the algorithm is provided and stepped through on a sample activity set to produce the optimal subset.
More Related Content
What's hot
Open addressiing &rehashing,extendiblevhashing
The document discusses various hash table implementation techniques. It describes open addressing hashing which resolves collisions by probing to the next empty cell. Linear probing is discussed as a collision resolution strategy where the next probe is the current index plus one. The document also covers separate chaining hashing which uses linked lists at each index to handle collisions, and double hashing which uses two hash functions to determine probe sequences.
Knapsack problem using greedy approach
In shared PPT we have discussed Knapsack problem using greedy approach and its two types i.e Fractional and 0-1
TOC 3 | Different Operations on DFA
This lecture covers:
1. Regular Language and Regular Operations
2. Closure properties of DFAs
3. Union of 2 DFA machines
4. Intersection of 2 DFA machines
5. Complement of DFA machines
Merge sort algorithm power point presentation
This is a merge sort algorithm presentation. Those are want to learn merge sort by a simple example , he/she can watch to understand easily
Travelling salesman dynamic programming
This document discusses the traveling salesman problem and a dynamic programming approach to solving it. It was presented by Maharaj Dey, a 6th semester CSE student with university roll number 11500117099 for the paper CS-681 (SEMINAR). The document concludes with a thank you.
Greedy method
The document discusses greedy algorithms and how they can be applied to solve optimization problems like the knapsack problem, activity selection problem, and job sequencing problem. It provides examples of greedy algorithms for each problem. A greedy algorithm works by making locally optimal choices at each step in the hope of finding a globally optimal solution. For the knapsack problem, the greedy approach sorts items by profit/weight ratio and fills the knapsack accordingly. For activity selection, it schedules activities based on earliest finish time. For job sequencing, it sorts jobs by profit and schedules the most profitable jobs that meet deadlines.
4.6 halting problem
The document discusses the halting problem and decidability of languages. It defines a decidable language as one where a Turing machine can accept or reject every input string and halt. The halting problem asks whether it is possible to determine if an arbitrary Turing machine will halt on a given input. The document proves the halting problem is undecidable by constructing a machine that contradicts itself, showing no algorithm can correctly determine if all Turing machines halt on all inputs.
Job sequencing with deadline
This document discusses the job sequencing problem, where the goal is to schedule jobs to be completed by their deadlines to maximize total profit. It provides an example problem with 4 jobs, their profits, deadlines, and the optimal solution of scheduling jobs J1 and J2 to earn a total profit of 140.
Algorithm Complexity and Main Concepts
An algorithm is a finite set of instructions to accomplish a predefined task. Performance of an algorithm is measured by its time and space complexity, with common metrics being big O, big Omega, and big Theta notation. Common data structures include arrays, linked lists, stacks, queues, trees and graphs. Key concepts are asymptotic analysis of algorithms, recursion, and analyzing complexity classes like constant, linear, quadratic and logarithmic time.
how to calclute time complexity of algortihm
This document discusses algorithm analysis and complexity. It defines key terms like asymptotic complexity, Big-O notation, and time complexity. It provides examples of analyzing simple algorithms like a sum function to determine their time complexity. Common analyses include looking at loops, nested loops, and sequences of statements. The goal is to classify algorithms according to their complexity, which is important for large inputs and machine-independent. Algorithms are classified based on worst, average, and best case analyses.
01 Knapsack using Dynamic Programming
Intoduction on Dynamic Programming & 0-1 Knapsack problem,
Implementation of 0-1 Knapsack using DP with example, its algorithm & analysis
sum of subset problem using Backtracking
Given a set of non-negative integers, and a value sum, determine if there is a subset of the given set with sum equal to given sum.
Sum of subsets problem by backtracking
We are given n distinct positive numbers (weights)
The objective is to find all combination of weights whose sum is equal to given weights m
State space tree is generated for all the possibilities of the subsets
Generate the tree by keeping weight <= m
Time complexity
Basic info about how to use time complexity and how to get the time of each program to solve the problem.
Recursion - Algorithms and Data Structures
Discuss different types of recursion with examples.
Linear/Binary/Multiple recursion
(Download is recommended to make the animations work)
Unification and Lifting
The document discusses inference rules for quantifiers in first-order logic. It describes the rules of universal instantiation and existential instantiation. Universal instantiation allows inferring sentences by substituting terms for variables, while existential instantiation replaces a variable with a new constant symbol. The document also introduces unification, which finds substitutions to make logical expressions identical. Generalized modus ponens is presented as a rule that lifts modus ponens to first-order logic by using unification to substitute variables.
Unit 2 in daa
1) The document describes the divide-and-conquer algorithm design paradigm. It can be applied to problems where the input can be divided into smaller subproblems, the subproblems can be solved independently, and the solutions combined to solve the original problem.
2) Binary search is provided as an example divide-and-conquer algorithm. It works by recursively dividing the search space in half and only searching the subspace containing the target value.
3) Finding the maximum and minimum elements in an array is also solved using divide-and-conquer. The array is divided into two halves, the max/min found for each subarray, and the overall max/min determined by comparing the subsolutions.
Webinar : P, NP, NP-Hard , NP - Complete problems
Problem | Problem v/s Algorithm v/s Program | Types of Problems | Computational complexity | P class v/s NP class Problems | Polynomial time v/s Exponential time | Deterministic v/s non-deterministic Algorithms | Functions of non-deterministic Algorithms | Non-deterministic searching Algorithm | Non-deterministic sorting Algorithm | NP - Hard and NP - Complete Problems | Reduction | properties of reduction | Satisfiability problem and Algorithm
Longest increasing subsequence
The document describes the longest increasing subsequence problem and a dynamic programming approach to solve it. The problem is to find the length of the longest subsequence of a given array where the elements are in increasing order. The dynamic programming approach uses an array to store the length of the longest increasing subsequence for each element by iterating through the original array. It starts by initializing each value in the array to 1, then iterates to update values where a longer subsequence can be formed by extending a previous subsequence. This takes O(n^2) time.
Asymptotic notation
This document introduces asymptotic notations that are used to describe the time complexity of algorithms. It defines big O, big Omega, and big Theta notations, which describe the limiting behavior of functions. Big O notation provides an asymptotic upper bound, big Omega provides a lower bound, and big Theta provides a tight bound. Examples are given of different asymptotic efficiency classes like constant, logarithmic, linear, quadratic, and exponential time. Properties of asymptotic notations like transitivity, reflexivity, symmetry, and transpose symmetry are also covered.
What's hot (20)
Open addressiing &rehashing,extendiblevhashing
Open addressiing &rehashing,extendiblevhashing
Viewers also liked
Activity selection problem class 12
The activity selection problem involves scheduling a shared resource among competing activities. Activities have start and finish times, and only one activity can use the resource at a time. A greedy algorithm finds a maximum set of compatible activities by sorting by finish time and sequentially selecting activities that do not overlap in time. The algorithm runs in O(n log n) time to sort activities and Θ(n) time to select activities, for a total runtime of O(n log n).
Activity selection problem
The document describes an activity selection problem where a set of activities must share a single resource. Each activity has a start and finish time, and activities are mutually compatible if one activity finishes before another starts. The problem is to find the maximum subset of mutually compatible activities. A recursive greedy algorithm is presented that takes the activities sorted by finish time and recursively selects the next compatible activity to build the subset. Pseudocode for the algorithm is provided and stepped through on a sample activity set to produce the optimal subset.
lecture 26
The document discusses various algorithms techniques including greedy algorithms, dynamic programming, and their application to problems like the activity selection problem and knapsack problem. It provides examples of optimal subproblems, overlapping subproblems, and how dynamic programming and greedy algorithms can be used to solve problems exhibiting these properties.
Stack and Hash Table
This document proposes a new approach to speed up combinatorial search strategies using stack and hash table data structures. The method uses a temporary array to help generate combinations in each iteration. A stack is created to push the first parameter, and the algorithm iterates popping values from the stack until it is empty. Indexes of a combination array are set to the stack length and popped values. Hashing provides a more reliable and flexible method of data retrieval than other structures, and is faster than searching arrays or lists. This approach could speed up generation and search processes for combinatorial approaches.
Lecture 5: Asymptotic analysis of algorithms
The document discusses asymptotic analysis of algorithms to analyze efficiency in terms of time and space complexity. It explains that the number of basic operations like arithmetic, data movement, and control operations determines time complexity, while space complexity depends on the number of basic data types used. Different algorithms for counting numbers with factorial divisible by 5 are analyzed to find their time complexity. The time complexity of an algorithm can be expressed using Θ notation, which describes the dominant term as the input size increases.
Matrix Multiplication(An example of concurrent programming)
its deals with how parallel programming can be achieved. its just an example of parallel programming.
Matrix multiplication
This document discusses parallel matrix multiplication algorithms on the Parallel Random Access Machine (PRAM) model. It describes algorithms that multiply matrices using different numbers of processors, from n3 processors down to n2 processors. The time complexity is O(log n) in all cases, while the processor and work complexities vary based on the number of processors. Block matrix multiplication is also introduced as a more efficient approach for shared memory machines by improving data locality.
strassen matrix multiplication algorithm
Strassen's algorithm improves upon the standard matrix multiplication algorithm by using divide and conquer and only requiring 7 recursive multiplications to multiply 2x2 submatrices rather than 8. This results in a running time of O(n^2.81) rather than O(n^3) for large matrix sizes. The algorithm divides the matrices into submatrices, recursively multiplies the submatrices using 7 intermediate terms rather than relying on the commutativity of multiplication, and combines the results. While the improvement may seem small, the reduced exponent means Strassen's algorithm performs better than the standard algorithm for matrices larger than about 32x32 due to the impact of the exponent on runtime.
BFS
This document describes graph search algorithms like breadth-first search (BFS) and their applications. It provides details on how BFS works, including that it maintains queues to search levels outwards from the starting vertex, and outputs the distance and predecessor of each vertex. BFS runs in O(V+E) time by visiting each vertex and edge once. The document also discusses how BFS can be used to find connected components in a graph and determine if a graph is bipartite.
Breadth first search
The document describes the steps of performing a breadth-first search (BFS) on a graph starting from node A. It shows how BFS enqueues nodes onto a FIFO queue as they are discovered and dequeues them to visit their neighbors, marking nodes as discovered along the way. The BFS finishes after all nodes reachable from A have been visited.
Divide and conquer 1
Binary search is an algorithm for finding an element in a sorted array. It works by recursively checking the middle element, dividing the array in half, and searching only one subarray. The time complexity is O(log n) as the array is divided in half in each step.
DFS and BFS
This document discusses and provides examples of depth-first search (DFS) and breadth-first search (BFS) algorithms for traversing graphs. It explains that DFS involves recursively exploring all branches of the graph as deep as possible before backtracking, while BFS involves searching the neighbors of the starting node first before moving to the next level. Examples are given showing the step-by-step process of applying DFS and BFS to traverse graphs and mark visited vertices.
Asymptotic notations
The document discusses asymptotic notations that are used to describe the time complexity of algorithms. It introduces big O notation, which describes asymptotic upper bounds, big Omega notation for lower bounds, and big Theta notation for tight bounds. Common time complexities are described such as O(1) for constant time, O(log N) for logarithmic time, and O(N^2) for quadratic time. The notations allow analyzing how efficiently algorithms use resources like time and space as the input size increases.
Introduction to Algorithms and Asymptotic Notation
Asymptotic Notation is a notation used to represent and compare the efficiency of algorithms. It is a concise notation that deliberately omits details, such as constant time improvements, etc. Asymptotic notation consists of 5 commonly used symbols: big oh, small oh, big omega, small omega, and theta.
Asymptotic Notations
Description of why we need asymptotic analysis and description various asymptotic notations with their properties
Asymptotic notations
1. Asymptotic notation such as Big-O, Omega, and Theta are used to describe the running time of algorithms as the input size n approaches infinity, rather than giving the exact running time.
2. Big-O notation gives an upper bound and describes worst-case running time, Omega notation gives a lower bound and describes best-case running time, and Theta notation gives a tight bound where the worst and best cases are equal up to a constant.
3. Common examples of asymptotic running times include O(1) for constant time, O(log n) for logarithmic time, O(n) for linear time, and O(n^2) for quadratic time.
Asymptotic Notation and Data Structures
This is the second lecture in the CS 6212 class. Covers asymptotic notation and data structures. Also outlines the coming lectures wherein we will study the various algorithm design techniques.
5.2 divide and conquer
This document discusses the merge sort algorithm for sorting a sequence of numbers. It begins by introducing the divide and conquer approach, which merge sort uses. It then provides an example of how merge sort works, dividing the sequence into halves, sorting the halves recursively, and then merging the sorted halves together. The document proceeds to provide pseudocode for the merge sort and merge algorithms. It analyzes the running time of merge sort using recursion trees, determining that it runs in O(n log n) time. Finally, it covers techniques for solving recurrence relations that arise in algorithms like divide and conquer approaches.
Divide and Conquer
The document discusses the divide-and-conquer algorithm design paradigm. It explains that a problem is divided into smaller subproblems, the subproblems are solved independently, and then the solutions are combined. Recurrence equations can be used to analyze the running time of divide-and-conquer algorithms. The document provides examples of solving recurrences using methods like the recursion tree method and the master theorem.
Elements of dynamic programming
An introductory project showing how to identify if a DP solution to a problem exists. It also discusses the essential parts of DP solutions briefly.
Viewers also liked (20)
Matrix Multiplication(An example of concurrent programming)
Matrix Multiplication(An example of concurrent programming)
Introduction to Algorithms and Asymptotic Notation
Introduction to Algorithms and Asymptotic Notation
More from fika sweety
Query optimization and performance
The document discusses the basic steps of query processing which include query parsing and translation to check syntax and transform the query to a relational algebra expression, query optimization to transform the initial query plan into the best plan based on the dataset by specifying operations and algorithms, and query evaluation to execute the optimized query plan and return the results.
Program design techniques
Business value of business models
Requirements for software development
Requirements provide a description of what a proposed software application should do. Without detailed requirements, application development projects fail. Business models capture this detail in a way that is understandable to both the business users and the software developers. Business users do not need to understand how the system will be created; they need to understand how it will support their need. Business models are a better form of requirements for end users.
Plsql
What is PL/SQL
Procedural Language – SQL
An extension to SQL with design features of programming languages (procedural and object oriented)
PL/SQL and Java are both supported as internal host languages within Oracle products.
Shift rotate
Shift and Rotate Instructions
Shift and Rotate Applications
Multiplication and Division Instructions
Extended Addition and Subtraction
ASCII and Packed Decimal Arithmetic
Graphss
Topological Sort
Given a graph, G = (V, E), output all the vertices in V such that no vertex is output before any other vertex with an edge to it.
Modeling and simulation ch 1
This document discusses the importance and value of business modeling. It begins by defining a business model as a simple representation of the complex reality of a business. It then describes the rise of business modeling, driven by the need for communication between parties, managing increasing complexity, and enabling change. The key benefits of business modeling include improved communication, training and learning, persuasion and selling, analysis of business situations, compliance management, software requirements development, and knowledge management. Integrating multiple modeling disciplines provides the most insightful models.
Macros...presentation
This document discusses macros in MASM assembly language. It defines macros as blocks of code that are given names and can be inserted into a program by MASM. It provides examples of macro definitions and invocations. It also discusses best practices for macros, such as restoring registers, handling arguments, avoiding duplicate local labels, and generating listings of macro expansions.
Pseudocode algorithim flowchart
Understand the relation between Algorithm and Pseudocode or program flowchart
Draw flowcharts
Write pseudocodes
Diversity (HRM)
Managers must value diversity in the workforce to access a broader range of viewpoints, reflect an increasingly diverse customer base, and obtain the best talent. Diversity brings both opportunities and challenges to managing organizations, including building an inclusive culture, developing bias-free HR systems, and addressing prejudice and stereotyping. Leveraging diversity through multicultural teams and employee networks can enhance creativity and problem-solving, while also requiring efforts to reduce potential for miscommunication.
Howtowriteamemo 090920105907-phpapp02
This document provides guidance on how to write an effective memo. It explains that a memo focuses on a single topic and makes a request or recommendation. The key parts of a memo are an introduction, audience and purpose, format, parts including a heading, opening, summary and discussion, and a closing. Examples of headings, introductions and discussions are provided to illustrate best practices for memo writing.
Coal presentationt
This document discusses disk structures and file handling. It covers floppy disks, hard disks, file allocation, how DOS reads and writes files using file handles, and basic file operations like create, write, read, delete and close. Disk structures include tracks, sectors, cylinders and partitions. File allocation uses a file allocation table to track file fragments across the disk.
1 Computer Architecture
The document provides an overview of computer architecture including definitions, trends, and principles of design. It defines architecture as how parts are assembled to achieve some goal, and discusses the architecture of chips, networks, and systems. It outlines classes of computers including desktops, servers, and embedded systems. The document also covers trends in technology such as Moore's law, trends in cost including learning curves and yield, and principles of measuring and comparing performance including benchmarks and metrics like execution time.
3 Pipelining
The document discusses pipelining in computer processors. It describes how pipelining can increase throughput by overlapping the execution of multiple instructions. It discusses the basic pipeline stages for a RISC instruction set, including fetch, decode, execute, memory access, and writeback. It also describes several types of pipeline hazards that can occur, such as structural hazards caused by resource conflicts, data hazards when instructions depend on previous results, and control hazards with branches. Forwarding techniques are presented to help address data hazards.
19 primkruskal
The document discusses two algorithms for finding minimum spanning trees: Prim's algorithm and Kruskal's algorithm. Prim's algorithm is similar to Dijkstra's algorithm for finding shortest paths. It works by gradually adding the closest vertex to the growing spanning tree. Kruskal's algorithm focuses on edges rather than vertices. It sorts the edges by weight and builds the spanning tree by adding the lowest weight edges that do not create cycles. Both algorithms find optimal minimum spanning trees for weighted and unweighted graphs.
Warehouse chapter3
This document defines a data warehouse as "an enterprise structured repository of subject-oriented, time-variant, historical data used for information retrieval and decision support." It then discusses key properties of data warehouses such as being integrated, time-variant, subject-oriented, and non-volatile. The document also contrasts data warehouses with operational transaction systems and describes common data warehouse implementations, components, and tools.
Storage memory
Disk memory provides large, non-volatile storage. It uses rotating platters coated with magnetic surfaces and read/write heads. Disk access time has four components - seek time to position the head, rotational latency to wait for the desired sector, transfer time to read/write data, and controller overhead time. RAID (redundant array of independent disks) uses multiple disks for performance, reliability, and availability. Popular RAID levels include RAID 1 which uses mirroring for redundancy, and RAID 5 which uses distributed parity blocks.
Quick sort
This document discusses the average-case analysis of quick sort. It assumes the running time T(n) of quick sort is less than c*n*log(n) for n greater than 2, where c is a constant. Quick sort is recursively splitting the list into sublists until each sublist contains a single element, and it has average-case performance of O(n log n).
Query optimization and performance
The document discusses the basic steps of query processing which include query parsing and translation to check syntax and transform the query to a relational algebra expression, query optimization to transform the initial query plan into the best plan based on the dataset by specifying operations and algorithms, and query evaluation to execute the optimized query plan and return the results.
L2
This document discusses techniques for solving recurrence relations that arise in the analysis of algorithms. It introduces the substitution method, where an educated guess for the solution is verified by induction. The recursion tree method provides intuition by modeling the recursive execution as a tree. Key examples are worked through. The master method is presented as a powerful tool for solving recurrences of the form T(n) = aT(n/b) + f(n), by comparing the growth rates of f(n) and nlogba.
Master theorem
This document provides an introduction to the Master Theorem, which can be used to determine the asymptotic runtime of recursive algorithms. It presents the three main conditions of the Master Theorem and examples of applying it to solve recurrence relations. It also notes some pitfalls in using the Master Theorem and briefly introduces a fourth condition for cases where the non-recursive term is polylogarithmic rather than polynomial.
More from fika sweety (20)
Recently uploaded
How to Manage Reception Report in Odoo 17
A business may deal with both sales and purchases occasionally. They buy things from vendors and then sell them to their customers. Such dealings can be confusing at times. Because multiple clients may inquire about the same product at the same time, after purchasing those products, customers must be assigned to them. Odoo has a tool called Reception Report that can be used to complete this assignment. By enabling this, a reception report comes automatically after confirming a receipt, from which we can assign products to orders.
220711130082 Srabanti Bag Internet Resources For Natural Science
Internet resources for natural science
INTRODUCTION TO HOSPITALS & AND ITS ORGANIZATION
The document discuss about the hospitals and it's organization .
How to Fix [Errno 98] address already in use
This slide will represent the cause of the error “[Errno 98] address already in use” and the troubleshooting steps to resolve this error in Odoo.
Accounting for Restricted Grants When and How To Record Properly
In this webinar, member learned how to stay in compliance with generally accepted accounting principles (GAAP) for restricted grants.
Level 3 NCEA - NZ: A Nation In the Making 1872 - 1900 SML.ppt
The History of NZ 1870-1900.
Making of a Nation.
From the NZ Wars to Liberals,
Richard Seddon, George Grey,
Social Laboratory, New Zealand,
Confiscations, Kotahitanga, Kingitanga, Parliament, Suffrage, Repudiation, Economic Change, Agriculture, Gold Mining, Timber, Flax, Sheep, Dairying,
BPSC-105 important questions for june term end exam
BPSC-105 important questions for june term end exam
How to Download & Install Module From the Odoo App Store in Odoo 17
Custom modules offer the flexibility to extend Odoo's capabilities, address unique requirements, and optimize workflows to align seamlessly with your organization's processes. By leveraging custom modules, businesses can unlock greater efficiency, productivity, and innovation, empowering them to stay competitive in today's dynamic market landscape. In this tutorial, we'll guide you step by step on how to easily download and install modules from the Odoo App Store.
Andreas Schleicher presents PISA 2022 Volume III - Creative Thinking - 18 Jun...
Andreas Schleicher, Director of Education and Skills at the OECD presents at the launch of PISA 2022 Volume III - Creative Minds, Creative Schools on 18 June 2024.
KHUSWANT SINGH.pptx ALL YOU NEED TO KNOW ABOUT KHUSHWANT SINGH
INDIA`S OWN LITERARY GENIUS MR.KHUSHWANT SINGH WAS TRULY A VERY BRAVE SOUL AND WAS AWARDED WITH THE MAGIC OF WORDS BY GOD.
Recently uploaded (20)
220711130082 Srabanti Bag Internet Resources For Natural Science
220711130082 Srabanti Bag Internet Resources For Natural Science
220711130088 Sumi Basak Virtual University EPC 3.pptx
220711130088 Sumi Basak Virtual University EPC 3.pptx
Accounting for Restricted Grants When and How To Record Properly
Accounting for Restricted Grants When and How To Record Properly
Level 3 NCEA - NZ: A Nation In the Making 1872 - 1900 SML.ppt
Level 3 NCEA - NZ: A Nation In the Making 1872 - 1900 SML.ppt
BPSC-105 important questions for june term end exam
BPSC-105 important questions for june term end exam
How to Download & Install Module From the Odoo App Store in Odoo 17
How to Download & Install Module From the Odoo App Store in Odoo 17
Andreas Schleicher presents PISA 2022 Volume III - Creative Thinking - 18 Jun...
Andreas Schleicher presents PISA 2022 Volume III - Creative Thinking - 18 Jun...
KHUSWANT SINGH.pptx ALL YOU NEED TO KNOW ABOUT KHUSHWANT SINGH
KHUSWANT SINGH.pptx ALL YOU NEED TO KNOW ABOUT KHUSHWANT SINGH
Activity selection problem
- 9. Example: A :
- 11. Top-down Greedy Algorithm • Goal: to compute max activity • Pseudo-code – Rec-Job-Select( s,f, i, n ) m = i + 1 while (m ≤ n) and ( < ) do m = m + 1 if m ≤ n return { } Rec-Job-Select(s, f, m, n) else return sm fi am