lecture 26
•Download as PPT, PDF•
5 likes•1,701 views
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.
Report
Share
Report
Share
![Review: Dynamic Programming ,[object Object],[object Object]](data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7)
Recommended
Greedy algorithm
The document discusses greedy algorithms and their application to optimization problems. It provides examples of problems that can be solved using greedy approaches, such as fractional knapsack and making change. However, it notes that some problems like 0-1 knapsack and shortest paths on multi-stage graphs cannot be solved optimally with greedy algorithms. The document also describes various greedy algorithms for minimum spanning trees, single-source shortest paths, and fractional knapsack problems.
A greedy algorithms
This document discusses greedy algorithms, which are algorithms that select locally optimal choices at each step in the hopes of finding a global optimum. It provides examples of problems that greedy algorithms can solve optimally, such as coin counting, and problems where greedy algorithms fail to find an optimal solution, such as scheduling jobs. It also analyzes the time complexity of various greedy algorithms, such as Dijkstra's algorithm for finding shortest paths.
Fractional knapsack class 13
The document discusses two types of knapsack problems - the 0-1 knapsack problem and the fractional knapsack problem. The 0-1 knapsack problem uses dynamic programming to determine how to fill a knapsack to maximize the total value of items without exceeding the knapsack's weight limit, where each item is either fully included or not included. The fractional knapsack problem allows partial inclusion of items and can be solved greedily by always including a fraction of the highest value per unit weight item until the knapsack is full.
Job sequencing with Deadlines
The document describes the job sequencing problem with deadlines and presents a greedy algorithm to solve it. The problem involves scheduling a set of jobs on a single processor to maximize total profit where each job has a deadline and profit. The greedy algorithm sorts jobs by decreasing profit and schedules each job as late as possible while meeting its deadline. This approach always finds the optimal solution that maximizes total profit. Pseudocode and a C++ program implementing the algorithm are also provided.
Greedy Algorithm
This document provides an introduction to greedy algorithms. It defines greedy algorithms as algorithms that make locally optimal choices at each step in the hope of finding a global optimum. The document then provides examples of problems that can be solved using greedy algorithms, including counting money, scheduling jobs, finding minimum spanning trees, and the traveling salesman problem. It also provides pseudocode for a general greedy algorithm and discusses some properties of greedy algorithms.
Dynamic pgmming
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.
Greedy algorithms
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.
Greedy algorithms
Greedy algorithms work by making locally optimal choices at each step to arrive at a global optimal solution. They require that the problem exhibits the greedy choice property and optimal substructure. Examples that can be solved with greedy algorithms include fractional knapsack problem, minimum spanning tree, and activity selection. The fractional knapsack problem is solved greedily by sorting items by value/weight ratio and filling the knapsack completely. The 0/1 knapsack problem differs in that items are indivisible.
Recommended
Greedy algorithm
The document discusses greedy algorithms and their application to optimization problems. It provides examples of problems that can be solved using greedy approaches, such as fractional knapsack and making change. However, it notes that some problems like 0-1 knapsack and shortest paths on multi-stage graphs cannot be solved optimally with greedy algorithms. The document also describes various greedy algorithms for minimum spanning trees, single-source shortest paths, and fractional knapsack problems.
A greedy algorithms
This document discusses greedy algorithms, which are algorithms that select locally optimal choices at each step in the hopes of finding a global optimum. It provides examples of problems that greedy algorithms can solve optimally, such as coin counting, and problems where greedy algorithms fail to find an optimal solution, such as scheduling jobs. It also analyzes the time complexity of various greedy algorithms, such as Dijkstra's algorithm for finding shortest paths.
Fractional knapsack class 13
The document discusses two types of knapsack problems - the 0-1 knapsack problem and the fractional knapsack problem. The 0-1 knapsack problem uses dynamic programming to determine how to fill a knapsack to maximize the total value of items without exceeding the knapsack's weight limit, where each item is either fully included or not included. The fractional knapsack problem allows partial inclusion of items and can be solved greedily by always including a fraction of the highest value per unit weight item until the knapsack is full.
Job sequencing with Deadlines
The document describes the job sequencing problem with deadlines and presents a greedy algorithm to solve it. The problem involves scheduling a set of jobs on a single processor to maximize total profit where each job has a deadline and profit. The greedy algorithm sorts jobs by decreasing profit and schedules each job as late as possible while meeting its deadline. This approach always finds the optimal solution that maximizes total profit. Pseudocode and a C++ program implementing the algorithm are also provided.
Greedy Algorithm
This document provides an introduction to greedy algorithms. It defines greedy algorithms as algorithms that make locally optimal choices at each step in the hope of finding a global optimum. The document then provides examples of problems that can be solved using greedy algorithms, including counting money, scheduling jobs, finding minimum spanning trees, and the traveling salesman problem. It also provides pseudocode for a general greedy algorithm and discusses some properties of greedy algorithms.
Dynamic pgmming
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.
Greedy algorithms
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.
Greedy algorithms
Greedy algorithms work by making locally optimal choices at each step to arrive at a global optimal solution. They require that the problem exhibits the greedy choice property and optimal substructure. Examples that can be solved with greedy algorithms include fractional knapsack problem, minimum spanning tree, and activity selection. The fractional knapsack problem is solved greedily by sorting items by value/weight ratio and filling the knapsack completely. The 0/1 knapsack problem differs in that items are indivisible.
Greedy Algorihm
This document outlines greedy algorithms, their characteristics, and examples of their use. Greedy algorithms make locally optimal choices at each step in the hopes of finding a global optimum. They are simple to implement and fast, but may not always reach the true optimal solution. Examples discussed include coin changing, traveling salesman, minimum spanning trees using Kruskal's and Prim's algorithms, and Huffman coding.
Backtracking
The document discusses the problem solving technique of backtracking. It begins by explaining backtracking as systematically trying and eliminating possibilities, using a maze as an example. It then provides the example of solving the eight queens problem using backtracking by placing queens on the board one at a time and backtracking when a placement leads to a conflict. Finally, it notes that other problems like Sudoku puzzles and mazes can also be solved using backtracking.
Branch and bound
Branch and Bound is a state space search algorithm that involves generating all children of a node before exploring any children. It uses lower bounds to prune parts of the search tree that cannot produce better solutions than what has already been found. The algorithm is demonstrated on problems like the 8-puzzle and Travelling Salesman Problem. For TSP, it works by reducing the cost matrix at each node to calculate lower bounds, and exploring the child with the lowest estimated total cost.
Data Structures- Hashing
This document discusses hashing techniques for indexing and retrieving elements in a data structure. It begins by defining hashing and its components like hash functions, collisions, and collision handling. It then describes two common collision handling techniques - separate chaining and open addressing. Separate chaining uses linked lists to handle collisions while open addressing resolves collisions by probing to find alternate empty slots using techniques like linear probing and quadratic probing. The document provides examples and explanations of how these hashing techniques work.
All pair shortest path
The document discusses the all pairs shortest path problem, which aims to find the shortest distance between every pair of vertices in a graph. It explains that the algorithm works by calculating the minimum cost to traverse between nodes using intermediate nodes, according to the equation A_k(i,j)=min{A_{k-1}(i,j), A_{k-1}(i,k), A_{k-1}(k,j)}. An example is provided to illustrate calculating the shortest path between nodes over multiple iterations of the algorithm.
Lecture 11 Informed Search
Heuristic search algorithms use heuristics, or problem-specific knowledge, to guide the search for a solution. Some heuristics guarantee completeness while others may sacrifice completeness to improve efficiency. A heuristic function estimates the cost to reach the goal state from the current state. For example, in the 8-puzzle problem the Manhattan distance heuristic estimates this cost as the sum of the distances each misplaced tile would need to move to reach its goal position. The example shows applying the Manhattan distance heuristic to guide the search for a solution to instances of the 8-puzzle problem.
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.
push down automata
This document provides an overview of pushdown automata (PDA). It defines a PDA as a finite automaton with an additional memory stack. This stack allows two operations - push, which adds a new symbol to the top of the stack, and pop, which removes and reads the top symbol. The document then discusses the formal definition of a PDA as a septuple and provides an example of a PDA that accepts the language of strings with an equal number of 0s and 1s. It concludes with an explanation of the state operations of replace, push, pop and no change and conditions for PDA acceptance and rejection.
backtracking algorithms of ada
The document describes the backtracking method for solving problems that require finding optimal solutions. Backtracking involves building a solution one component at a time and using bounding functions to prune partial solutions that cannot lead to an optimal solution. It then provides examples of applying backtracking to solve the 8 queens problem by placing queens on a chessboard with no attacks. The general backtracking method and a recursive backtracking algorithm are also outlined.
The n Queen Problem
This document summarizes the n-queen problem, which involves placing N queens on an N x N chessboard so that no queen can attack any other. It describes the problem's inputs and tasks, provides examples of solutions for different board sizes, and outlines the backtracking algorithm commonly used to solve this problem. The backtracking approach guarantees a solution but can be slow, with complexity rising exponentially with problem size. It is a good benchmark for testing parallel computing systems due to its iterative nature.
Informed search (heuristics)
1) The document discusses various search algorithms including uninformed searches like breadth-first search as well as informed searches using heuristics.
2) It describes greedy best-first search which uses a heuristic function to select the node closest to the goal at each step, and A* search which uses both path cost and heuristic cost to guide the search.
3) Genetic algorithms are introduced as a search technique that generates successors by combining two parent states through crossover and mutation rather than expanding single nodes.
Lecture 24 iterative improvement algorithm
Iterative improvement algorithms are suitable for optimization problems where the path to a solution is irrelevant and the goal state itself is the solution. These algorithms maintain a single current state and try to iteratively improve it. Some key advantages are that they only require tracking the current state, saving memory, and are suitable for both online and offline search. Examples of problems that can use iterative improvement algorithms include the traveling salesman problem and N-Queens problem.
Heuristic Search Techniques Unit -II.ppt
This document discusses various heuristic search techniques used in artificial intelligence. It begins by defining heuristics as techniques that find approximate solutions faster than classic methods when exact solutions are not possible or not feasible due to time or memory constraints. It then describes heuristic search, hill climbing, simulated annealing, A* search, and best-first search. Hill climbing is presented as an example heuristic technique that evaluates neighboring states to move toward an optimal solution. The document also discusses problems that can occur with hill climbing like getting stuck in local maxima.
N Queens problem
This document describes a project on solving the 8 queens problem using object-oriented programming in C++. It includes an introduction to the 8 queens puzzle, a methodology section on the backtracking algorithm used, pseudocode for the algorithm, analysis of the time complexity, a flowchart, results and discussion of the 12 fundamental solutions, and the source code. It was completed by 5 students under the guidance of a professor to fulfill the requirements for a bachelor's degree in computer science and engineering.
Chomsky Hierarchy.ppt
This document discusses the Chomsky hierarchy and different types of automata and grammars. It begins by describing applications of different automata like Turing machines, linear bounded automata, pushdown automata, and finite automata. It then discusses recursive and enumerable sets and linear bounded automata. It provides examples of languages accepted by LBAs and notes that LBAs have more power than PDAs but less than TMs. It also discusses unrestricted grammars, context-sensitive grammars, and places language classes in the Chomsky hierarchy. It concludes by asking questions about left linear versus right linear grammars.
Longest Common Subsequence
After a long period, I bring you new - fresh Presentation which gives you a brief idea on sub-problem of Dynamic Programming which is called as -"Longest Common Subsequence".I hope this presentation may help to all my viewers....
Asymptotic Notations
Description of why we need asymptotic analysis and description various asymptotic notations with their properties
AI 3 | Uninformed Search
The document discusses various search strategies for solving problems like the 8-puzzle game. It defines key concepts like search, state space graphs, search trees, step costs, path costs, and solutions. It explains uninformed and informed search strategies. Specifically it covers breadth-first search, uniform-cost search, and depth-first search algorithms. It provides examples of applying these algorithms to sample state space graphs and discusses their time and space complexities.
Daa:Dynamic Programing
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.
Backtracking
This document discusses various problems that can be solved using backtracking, including graph coloring, the Hamiltonian cycle problem, the subset sum problem, the n-queen problem, and map coloring. It provides examples of how backtracking works by constructing partial solutions and evaluating them to find valid solutions or determine dead ends. Key terms like state-space trees and promising vs non-promising states are introduced. Specific examples are given for problems like placing 4 queens on a chessboard and coloring a map of Australia.
Chapter 17
The document describes greedy algorithms and how they work. It provides an example of an activity selection problem that can be solved using a greedy algorithm in O(n) time by always selecting the activity with the earliest finish time that does not conflict with previously selected activities. It also discusses how Huffman codes can be constructed greedily by always merging the two lowest frequency characters into a node, resulting in an optimal prefix coding tree.
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.
More Related Content
What's hot
Greedy Algorihm
This document outlines greedy algorithms, their characteristics, and examples of their use. Greedy algorithms make locally optimal choices at each step in the hopes of finding a global optimum. They are simple to implement and fast, but may not always reach the true optimal solution. Examples discussed include coin changing, traveling salesman, minimum spanning trees using Kruskal's and Prim's algorithms, and Huffman coding.
Backtracking
The document discusses the problem solving technique of backtracking. It begins by explaining backtracking as systematically trying and eliminating possibilities, using a maze as an example. It then provides the example of solving the eight queens problem using backtracking by placing queens on the board one at a time and backtracking when a placement leads to a conflict. Finally, it notes that other problems like Sudoku puzzles and mazes can also be solved using backtracking.
Branch and bound
Branch and Bound is a state space search algorithm that involves generating all children of a node before exploring any children. It uses lower bounds to prune parts of the search tree that cannot produce better solutions than what has already been found. The algorithm is demonstrated on problems like the 8-puzzle and Travelling Salesman Problem. For TSP, it works by reducing the cost matrix at each node to calculate lower bounds, and exploring the child with the lowest estimated total cost.
Data Structures- Hashing
This document discusses hashing techniques for indexing and retrieving elements in a data structure. It begins by defining hashing and its components like hash functions, collisions, and collision handling. It then describes two common collision handling techniques - separate chaining and open addressing. Separate chaining uses linked lists to handle collisions while open addressing resolves collisions by probing to find alternate empty slots using techniques like linear probing and quadratic probing. The document provides examples and explanations of how these hashing techniques work.
All pair shortest path
The document discusses the all pairs shortest path problem, which aims to find the shortest distance between every pair of vertices in a graph. It explains that the algorithm works by calculating the minimum cost to traverse between nodes using intermediate nodes, according to the equation A_k(i,j)=min{A_{k-1}(i,j), A_{k-1}(i,k), A_{k-1}(k,j)}. An example is provided to illustrate calculating the shortest path between nodes over multiple iterations of the algorithm.
Lecture 11 Informed Search
Heuristic search algorithms use heuristics, or problem-specific knowledge, to guide the search for a solution. Some heuristics guarantee completeness while others may sacrifice completeness to improve efficiency. A heuristic function estimates the cost to reach the goal state from the current state. For example, in the 8-puzzle problem the Manhattan distance heuristic estimates this cost as the sum of the distances each misplaced tile would need to move to reach its goal position. The example shows applying the Manhattan distance heuristic to guide the search for a solution to instances of the 8-puzzle problem.
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.
push down automata
This document provides an overview of pushdown automata (PDA). It defines a PDA as a finite automaton with an additional memory stack. This stack allows two operations - push, which adds a new symbol to the top of the stack, and pop, which removes and reads the top symbol. The document then discusses the formal definition of a PDA as a septuple and provides an example of a PDA that accepts the language of strings with an equal number of 0s and 1s. It concludes with an explanation of the state operations of replace, push, pop and no change and conditions for PDA acceptance and rejection.
backtracking algorithms of ada
The document describes the backtracking method for solving problems that require finding optimal solutions. Backtracking involves building a solution one component at a time and using bounding functions to prune partial solutions that cannot lead to an optimal solution. It then provides examples of applying backtracking to solve the 8 queens problem by placing queens on a chessboard with no attacks. The general backtracking method and a recursive backtracking algorithm are also outlined.
The n Queen Problem
This document summarizes the n-queen problem, which involves placing N queens on an N x N chessboard so that no queen can attack any other. It describes the problem's inputs and tasks, provides examples of solutions for different board sizes, and outlines the backtracking algorithm commonly used to solve this problem. The backtracking approach guarantees a solution but can be slow, with complexity rising exponentially with problem size. It is a good benchmark for testing parallel computing systems due to its iterative nature.
Informed search (heuristics)
1) The document discusses various search algorithms including uninformed searches like breadth-first search as well as informed searches using heuristics.
2) It describes greedy best-first search which uses a heuristic function to select the node closest to the goal at each step, and A* search which uses both path cost and heuristic cost to guide the search.
3) Genetic algorithms are introduced as a search technique that generates successors by combining two parent states through crossover and mutation rather than expanding single nodes.
Lecture 24 iterative improvement algorithm
Iterative improvement algorithms are suitable for optimization problems where the path to a solution is irrelevant and the goal state itself is the solution. These algorithms maintain a single current state and try to iteratively improve it. Some key advantages are that they only require tracking the current state, saving memory, and are suitable for both online and offline search. Examples of problems that can use iterative improvement algorithms include the traveling salesman problem and N-Queens problem.
Heuristic Search Techniques Unit -II.ppt
This document discusses various heuristic search techniques used in artificial intelligence. It begins by defining heuristics as techniques that find approximate solutions faster than classic methods when exact solutions are not possible or not feasible due to time or memory constraints. It then describes heuristic search, hill climbing, simulated annealing, A* search, and best-first search. Hill climbing is presented as an example heuristic technique that evaluates neighboring states to move toward an optimal solution. The document also discusses problems that can occur with hill climbing like getting stuck in local maxima.
N Queens problem
This document describes a project on solving the 8 queens problem using object-oriented programming in C++. It includes an introduction to the 8 queens puzzle, a methodology section on the backtracking algorithm used, pseudocode for the algorithm, analysis of the time complexity, a flowchart, results and discussion of the 12 fundamental solutions, and the source code. It was completed by 5 students under the guidance of a professor to fulfill the requirements for a bachelor's degree in computer science and engineering.
Chomsky Hierarchy.ppt
This document discusses the Chomsky hierarchy and different types of automata and grammars. It begins by describing applications of different automata like Turing machines, linear bounded automata, pushdown automata, and finite automata. It then discusses recursive and enumerable sets and linear bounded automata. It provides examples of languages accepted by LBAs and notes that LBAs have more power than PDAs but less than TMs. It also discusses unrestricted grammars, context-sensitive grammars, and places language classes in the Chomsky hierarchy. It concludes by asking questions about left linear versus right linear grammars.
Longest Common Subsequence
After a long period, I bring you new - fresh Presentation which gives you a brief idea on sub-problem of Dynamic Programming which is called as -"Longest Common Subsequence".I hope this presentation may help to all my viewers....
Asymptotic Notations
Description of why we need asymptotic analysis and description various asymptotic notations with their properties
AI 3 | Uninformed Search
The document discusses various search strategies for solving problems like the 8-puzzle game. It defines key concepts like search, state space graphs, search trees, step costs, path costs, and solutions. It explains uninformed and informed search strategies. Specifically it covers breadth-first search, uniform-cost search, and depth-first search algorithms. It provides examples of applying these algorithms to sample state space graphs and discusses their time and space complexities.
Daa:Dynamic Programing
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.
Backtracking
This document discusses various problems that can be solved using backtracking, including graph coloring, the Hamiltonian cycle problem, the subset sum problem, the n-queen problem, and map coloring. It provides examples of how backtracking works by constructing partial solutions and evaluating them to find valid solutions or determine dead ends. Key terms like state-space trees and promising vs non-promising states are introduced. Specific examples are given for problems like placing 4 queens on a chessboard and coloring a map of Australia.
What's hot (20)
Viewers also liked
Chapter 17
The document describes greedy algorithms and how they work. It provides an example of an activity selection problem that can be solved using a greedy algorithm in O(n) time by always selecting the activity with the earliest finish time that does not conflict with previously selected activities. It also discusses how Huffman codes can be constructed greedily by always merging the two lowest frequency characters into a node, resulting in an optimal prefix coding tree.
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.
Activity selection problem
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.
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.
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.
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).
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.
Lec30
This document discusses various algorithm design methods and optimization problems. It provides examples of greedy algorithms for problems like machine scheduling, bin packing, and the 0/1 knapsack problem. While greedy algorithms provide efficient solutions, they do not always find the optimal solution. The document explores different greedy heuristics for the 0/1 knapsack problem and analyzes their performance compared to the best possible solution.
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.
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.
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.
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
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.
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
Similar to lecture 26
lecture 27
The document discusses NP-completeness and algorithms. It introduces dynamic programming and greedy algorithms. It then discusses the activity selection problem and shows it can be solved greedily by choosing the activity with the earliest finish time at each step. Finally, it defines the classes P and NP, introduces the concept of reductions to show problems are NP-complete, and states that if any NP-complete problem can be solved in polynomial time, then P=NP.
Dynamic programming
Dynamic Programming is a method for solving a complex problem by breaking it down into a collection of simpler subproblems, solving each of those subproblems just once, and storing their solutions using a memory-based data structure (array, map,etc).
Analysis and Design of Algorithms notes
This document provides an introduction to algorithms and their analysis. It defines what an algorithm is and discusses different aspects of analyzing algorithm performance, including time complexity, space complexity, asymptotic analysis using Big O, Big Theta, and Big Omega notations. It also covers greedy algorithms, their characteristics, and examples like the knapsack problem. Greedy algorithms make locally optimal choices at each step without reconsidering prior decisions. Not all problems can be solved greedily, and the document discusses when greedy algorithms can and cannot be applied.
Greedy algorithms -Making change-Knapsack-Prim's-Kruskal's
The document discusses greedy algorithms, which attempt to find optimal solutions to optimization problems by making locally optimal choices at each step that are also globally optimal. It provides examples of problems that greedy algorithms can solve optimally, such as minimum spanning trees and change making, as well as problems they can provide approximations for, like the knapsack problem. Specific greedy algorithms covered include Kruskal's and Prim's for minimum spanning trees.
Greedy
The document discusses the greedy method algorithm design paradigm. It can be used to solve optimization problems with the greedy-choice property, where choosing locally optimal decisions at each step leads to a globally optimal solution. Examples discussed include fractional knapsack problem, task scheduling, and making change problem. The greedy algorithm works by always making the choice that looks best at the moment, without considering future implications of that choice.
Algorithms Design Patterns
The document discusses various algorithms design approaches and patterns including divide and conquer, greedy algorithms, dynamic programming, backtracking, and branch and bound. It provides examples of each along with pseudocode. Specific algorithms discussed include binary search, merge sort, knapsack problem, shortest path problems, and the traveling salesman problem. The document is authored by Ashwin Shiv, a second year computer science student at NIT Delhi.
Greedy1.ppt
This document discusses algorithms for solving optimization problems like the activity selection problem and knapsack problem. It explains that activity selection can be solved greedily by always selecting the shortest remaining activity that does not conflict with previous selections. The knapsack problem cannot be solved greedily but can be solved using dynamic programming by breaking it into overlapping subproblems and storing results in a table.
DynamicProgramming.pptx
Dynamic programming is a powerful technique for solving optimization problems by breaking them down into overlapping subproblems. It works by storing solutions to already solved subproblems and building up to a solution for the overall problem. Three key aspects are defining the subproblems, writing the recurrence relation, and solving base cases to build up solutions bottom-up rather than top-down. The principle of optimality must also hold for a problem to be suitable for a dynamic programming approach. Examples discussed include shortest paths, coin change, knapsack problems, and calculating Fibonacci numbers.
Mastering Greedy Algorithms: Optimizing Solutions for Efficiency"
Greedy algorithms are fundamental techniques used in computer science and optimization problems. They belong to a class of algorithms that make decisions based on the current best option without considering the overall future consequences. Despite their simplicity and intuitive appeal, greedy algorithms can provide efficient solutions to a wide range of problems across various domains.
At the core of greedy algorithms lies a simple principle: at each step, choose the locally optimal solution that seems best at the moment, with the hope that it will lead to a globally optimal solution. This principle makes greedy algorithms easy to understand and implement, as they typically involve iterating through a set of choices and making decisions based on some criteria.
One of the key characteristics of greedy algorithms is their greedy choice property, which states that at each step, the locally optimal choice leads to an optimal solution overall. This property allows greedy algorithms to make decisions without needing to backtrack or reconsider previous choices, resulting in efficient solutions for many problems.
Greedy algorithms are commonly used in problems involving optimization, scheduling, and combinatorial optimization. Examples include finding the minimum spanning tree in a graph (Prim's and Kruskal's algorithms), finding the shortest path in a weighted graph (Dijkstra's algorithm), and scheduling tasks to minimize completion time (interval scheduling).
Despite their effectiveness in many situations, greedy algorithms may not always produce the optimal solution for a given problem. In some cases, a greedy approach can lead to suboptimal solutions that are not globally optimal. This occurs when the greedy choice property does not guarantee an optimal solution at each step, or when there are conflicting objectives that cannot be resolved by a greedy strategy alone.
To mitigate these limitations, it is essential to carefully analyze the problem at hand and determine whether a greedy approach is appropriate. In some cases, greedy algorithms can be augmented with additional techniques or heuristics to improve their performance or guarantee optimality. Alternatively, other algorithmic paradigms such as dynamic programming or divide and conquer may be better suited for certain problems.
Overall, greedy algorithms offer a powerful and versatile tool for solving optimization problems efficiently. By understanding their principles and characteristics, programmers and researchers can leverage greedy algorithms to tackle a wide range of computational challenges and design elegant solutions that balance simplicity and effectiveness.
Ms nikita greedy agorithm
The document discusses greedy algorithms and the knapsack problem. It defines greedy algorithms as making locally optimal choices at each step to find a global optimum. The general method is described as starting with a small solution and building up, making short-sighted choices. Knapsack problems aim to fill a knapsack of size S with items of varying sizes and values, often choosing items with the highest value-to-size ratios first. The fractional knapsack problem allows items to be partially selected to maximize total value within the size limit.
Optimization problems
Optimization problems can be divided into two categories, depending on whether the variables are continuous or discrete:
An optimization problem with discrete variables is known as a discrete optimization, in which an object such as an integer, permutation or graph must be found from a countable set.
A problem with continuous variables is known as a continuous optimization, in which an optimal value from a continuous function must be found. They can include constrained problems and multimodal problems.
Greedy method1
This document discusses the greedy method algorithm design technique. It explains that greedy algorithms make locally optimal choices at each step to find a global solution. The document provides examples of problems that can be solved with greedy algorithms, including making change with coins, the fractional knapsack problem, and task scheduling. It describes the greedy choice, objective function, and correctness proof for each problem.
Parallel_Algorithms_In_Combinatorial_Optimization_Problems.ppt
The document discusses various parallel algorithms for combinatorial optimization problems. It covers topics like branch and bound, backtracking, divide and conquer, and greedy methods. Branch and bound is described as a general algorithm for finding optimal solutions that systematically enumerates candidates and discards subsets that cannot lead to optimal solutions. Backtracking is presented as a systematic way to search a problem space by incrementally building candidates and abandoning partial candidates when they cannot be completed. Divide and conquer is characterized as an approach that breaks problems into subproblems, solves the subproblems, and combines the solutions. Greedy methods are defined as making locally optimal choices at each stage to find a global optimum. Examples like the knapsack problem are provided.
Parallel_Algorithms_In_Combinatorial_Optimization_Problems.ppt
The document discusses various parallel algorithms for combinatorial optimization problems. It covers topics like branch and bound, backtracking, divide and conquer, and greedy methods. Branch and bound is described as a general algorithm that uses pruning to discard subsets of solutions that are provably not optimal. Backtracking systematically searches the solution space but abandons partial candidates ("backtracks") when it determines they cannot be completed. Divide and conquer works by recursively breaking problems into independent subproblems until simple enough to solve directly. Greedy algorithms make locally optimal choices at each step to hopefully find a global optimum.
Data Analysis and Algorithms Lecture 1: Introduction
This document outlines a course on design and analysis of algorithms. It covers topics like algorithm complexity analysis using growth functions, classic algorithm problems like the traveling salesperson problem, and algorithm design techniques like divide-and-conquer, greedy algorithms, and dynamic programming. Example algorithms and problems are provided for each topic. Reference books on algorithms are also listed.
Greedy Algorithms WITH Activity Selection Problem.ppt
An Activity Selection Problem
The activity selection problem is a mathematical optimization problem. Our first illustration is the problem of scheduling a resource among several challenge activities. We find a greedy algorithm provides a well designed and simple method for selecting a maximum- size set of manually compatible activities.
BackTracking Algorithm: Technique and Examples
This slides gives a strong overview of backtracking algorithm. How it came and general approaches of the techniques. Also some well-known problem and solution of backtracking algorithm.
Back tracking
Backtracking is a technique for solving problems by incrementally building candidates to the solutions, and abandoning each partial candidate ("backtracking") as soon as it is determined that the candidate cannot possibly be completed to a valid solution. It is useful for problems with constraints or complex conditions that are difficult to test incrementally. The key steps are: 1) systematically generate potential solutions; 2) test if a solution is complete and satisfies all constraints; 3) if not, backtrack and vary the previous choice. Backtracking has been used to solve problems like the N-queens puzzle, maze generation, Sudoku puzzles, and finding Hamiltonian cycles in graphs.
Greedy Algorithm - Knapsack Problem
The document discusses the knapsack problem and greedy algorithms. It defines the knapsack problem as an optimization problem where given constraints and an objective function, the goal is to find the feasible solution that maximizes or minimizes the objective. It describes the knapsack problem has having two versions: 0-1 where items are indivisible, and fractional where items can be divided. The fractional knapsack problem can be solved using a greedy approach by sorting items by value to weight ratio and filling the knapsack accordingly until full.
GreedyAlgorithms.ppt
The document describes greedy algorithms and their application to activity selection problems. It shows how a dynamic programming solution can be converted to a greedy algorithm by proving that choosing the activity with the earliest finish time at each step leads to the globally optimal solution. This greedy strategy reduces the number of subproblems and choices needed compared to dynamic programming. The document then extends the approach to solve the maximum attendance problem by greedily selecting activities to maximize total attendance.
Similar to lecture 26 (20)
Greedy algorithms -Making change-Knapsack-Prim's-Kruskal's
Greedy algorithms -Making change-Knapsack-Prim's-Kruskal's
Mastering Greedy Algorithms: Optimizing Solutions for Efficiency"
Mastering Greedy Algorithms: Optimizing Solutions for Efficiency"
Parallel_Algorithms_In_Combinatorial_Optimization_Problems.ppt
Parallel_Algorithms_In_Combinatorial_Optimization_Problems.ppt
Parallel_Algorithms_In_Combinatorial_Optimization_Problems.ppt
Parallel_Algorithms_In_Combinatorial_Optimization_Problems.ppt
Data Analysis and Algorithms Lecture 1: Introduction
Data Analysis and Algorithms Lecture 1: Introduction
Greedy Algorithms WITH Activity Selection Problem.ppt
Greedy Algorithms WITH Activity Selection Problem.ppt
More from sajinsc
lecture 30
The document reviews concepts related to NP-completeness, including reductions between problems. It provides examples of reducing the directed Hamiltonian cycle problem to the undirected version. It also reduces 3-SAT to the clique problem by transforming a Boolean formula to a graph, then further reduces clique to vertex cover. Hundreds of problems have been shown to be NP-complete through relatively simple reductions like these that leverage previous results.
lecture 29
The document discusses reductions between problems to prove NP-completeness. It first reviews P, NP, reductions, NP-hard and NP-complete problems. It then walks through reducing directed Hamiltonian cycle to undirected Hamiltonian cycle to traveling salesman problem (TSP) to prove that TSP is NP-complete in 3 steps or less.
lecture 28
This document discusses NP-completeness and algorithms. It begins by reviewing tractable versus intractable problems, and the complexity classes P and NP. P contains problems solvable in polynomial time, while NP includes problems verifiable in polynomial time. The document then discusses NP-complete problems, which are the hardest problems in NP. It notes that reducing one problem to another shows the first problem is no harder than the second. The document concludes by outlining the steps to prove a problem is NP-complete: choosing a known NP-complete problem, reducing it to the target problem in polynomial time, and showing the target is in NP.
lecture 25
The document describes the 0-1 knapsack problem and how to solve it using dynamic programming. The 0-1 knapsack problem involves packing items of different weights and values into a knapsack of maximum capacity to maximize the total value without exceeding the weight limit. A dynamic programming algorithm is presented that breaks the problem down into subproblems and uses optimal substructure and overlapping subproblems to arrive at the optimal solution in O(nW) time, improving on the brute force O(2^n) time. An example is shown step-by-step to illustrate the algorithm.
lecture 24
The document discusses dynamic programming and its application to solving the longest common subsequence (LCS) problem. It presents the LCS algorithm, which uses dynamic programming to find the length and sequence of the longest subsequence common to two strings X and Y in O(mn) time, where m and n are the lengths of X and Y, respectively. It provides an example running the LCS algorithm on strings X="ABCB" and Y="BDCAB" to determine their longest common subsequence is "BCB".
lecture 23
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.
lecture 22
The document discusses algorithms and data structures covered in a CS algorithms course, including Dijkstra's algorithm, Bellman-Ford algorithm, shortest paths in DAGs, Kruskal's algorithm for minimum spanning trees, and disjoint-set union data structures. It provides examples and explanations of how each algorithm works.
lecture 21
The document discusses algorithms for solving the single-source shortest path problem, including Dijkstra's algorithm, Bellman-Ford algorithm, and shortest paths in directed acyclic graphs (DAGs). It reviews the key ideas behind relaxation and how algorithms like Bellman-Ford and Dijkstra's use relaxation to iteratively improve the upper bound on shortest path distances. Running times of the algorithms are analyzed, with Dijkstra's algorithm taking O(ElogV) time and Bellman-Ford taking O(VE) time.
lecture 20
The document describes Prim's algorithm for finding a minimum spanning tree (MST) of a weighted undirected graph. It shows the pseudocode for Prim's algorithm and step-by-step workings on an example graph to build up the MST. It notes that the key operation is decreasing the key value, which is called once for each edge in the MST, and the running time depends on the priority queue implementation, being O(ElgV) for a binary heap and O(VlgV+E) for a Fibonacci heap.
lecture 19
The document discusses depth-first search (DFS) graph algorithms. DFS explores a graph by going as deep as possible at each step and backtracking when no further progress can be made. It distinguishes between different types of edges discovered: tree edges connect newly found nodes, back edges connect to ancestors, and cross/forward edges connect between subtrees or ancestors and descendants. DFS runs in O(V+E) time and can detect cycles in O(V) time by checking for back edges.
lecture 18
The document discusses the algorithms of breadth-first search (BFS) and depth-first search (DFS) on graphs. It provides pseudocode for BFS and DFS, and examples of running the algorithms on sample graphs. Key points include:
- BFS uses a queue to explore all neighbors of a vertex before moving to the next level. It finds the shortest paths from the source.
- DFS uses recursion to explore as deep as possible before backtracking. It identifies tree edges, back edges, and forward edges.
- Both BFS and DFS run in O(V+E) time on a graph with V vertices and E edges.
lecture 17
The document discusses interval trees and breadth-first search (BFS) algorithms. Interval trees are used to maintain a set of intervals and efficiently find overlapping intervals given a query. BFS is a graph search algorithm that explores all neighboring vertices of a starting node before moving to neighbors of neighbors. BFS builds a breadth-first tree and calculates the shortest path distances from the source node in O(V+E) time and space.
lecture 16
The document discusses algorithms for finding minimum spanning trees in graphs. It describes two common algorithms: Kruskal's algorithm and Prim's algorithm. Kruskal's algorithm sorts the edges by weight and builds up the spanning tree by adding edges that do not create cycles. Prim's algorithm maintains a set of vertices in the spanning tree and iteratively adds the lowest weight edge connecting a vertex outside the set to one inside. Both run in O((V+E)logV) time using efficient data structures.
lecture 15
The document discusses two algorithms for matrix multiplication and finding the median of an unsorted list:
1) Strassen's algorithm improves on the traditional O(n^3) matrix multiplication algorithm by using divide and conquer to achieve O(n^lg7) time complexity.
2) Finding the median can be done in expected O(n) time using quickselect, or deterministically in O(n) time by choosing the median of medians as the pivot.
lecture 14
The document discusses red-black trees and their operations. It reviews the properties of red-black trees that guarantee logarithmic height. It then describes that inserting nodes can violate properties and requires recoloring nodes or rotating the tree. The key steps of insertion involve adding the new node as red, then fixing any violations by moving them up the tree through recoloring and rotations.
lecture 13
The document discusses red-black trees, which are binary search trees augmented with node colors to guarantee a height of O(log n). It describes the properties that red-black trees must satisfy, including that every node is red or black, leaves are black, and if a node is red its children are black. It then proves that these properties ensure the height is O(log n) by showing a subtree has at least 2^bh - 1 nodes, where bh is the black-height. Finally, it notes that common operations like search, insert and delete run in O(log n) time on red-black trees.
lecture 12
The document discusses binary search trees (BSTs) and their use as a data structure for dynamic sets. It covers BST properties, operations like search, insert, delete and their running times. It also discusses using BSTs to sort an array in O(n lg n) time by inserting elements, similar to quicksort. Maintaining a height of O(lg n) is important for efficient operations.
lecture 11
This document discusses binary search trees (BSTs) and their use for dynamic sets and sorting. It covers BST operations like search, insert, find minimum/maximum, and delete. It explains that BST sorting runs in O(n log n) time like quicksort. Maintaining a height of O(log n) can lead to efficient implementations of priority queues and other dynamic set applications using BSTs.
lecture 10
The document discusses various sorting algorithms and their time complexities:
1. Comparison sorts like merge sort and quicksort have a best case time complexity of O(n log n).
2. Counting sort runs in O(n+k) time where k is the range of input values, and is not a comparison sort.
3. Radix sort treats input as d-digit numbers in some base k and uses counting sort to sort on each digit, achieving O(dn+dk) time which is O(n) when d and k are constants.
4. A randomized selection algorithm finds the ith order statistic in expected O(n) time using randomized partition.
lecture 9
The document discusses various sorting algorithms and their time complexities, including:
- Insertion sort runs in O(n^2) time in the worst case.
- Merge sort and heap sort run in O(nlogn) time in the worst case.
- Any comparison-based sorting algorithm requires Ω(nlogn) time.
- Counting sort and radix sort can run in O(n) time by avoiding comparisons, but have additional requirements on the key range.
More from sajinsc (20)
Recently uploaded
Introduction to AI for Nonprofits with Tapp Network
Dive into the world of AI! Experts Jon Hill and Tareq Monaur will guide you through AI's role in enhancing nonprofit websites and basic marketing strategies, making it easy to understand and apply.
South African Journal of Science: Writing with integrity workshop (2024)
South African Journal of Science: Writing with integrity workshop (2024)Academy of Science of South Africa
A workshop hosted by the South African Journal of Science aimed at postgraduate students and early career researchers with little or no experience in writing and publishing journal articles.How to Manage Your Lost Opportunities in Odoo 17 CRM
Odoo 17 CRM allows us to track why we lose sales opportunities with "Lost Reasons." This helps analyze our sales process and identify areas for improvement. Here's how to configure lost reasons in Odoo 17 CRM
Chapter 4 - Islamic Financial Institutions in Malaysia.pptx
Chapter 4 - Islamic Financial Institutions in Malaysia.pptxMohd Adib Abd Muin, Senior Lecturer at Universiti Utara Malaysia
This slide is special for master students (MIBS & MIFB) in UUM. Also useful for readers who are interested in the topic of contemporary Islamic banking.
How to Add Chatter in the odoo 17 ERP Module
In Odoo, the chatter is like a chat tool that helps you work together on records. You can leave notes and track things, making it easier to talk with your team and partners. Inside chatter, all communication history, activity, and changes will be displayed.
Natural birth techniques - Mrs.Akanksha Trivedi Rama University
Natural birth techniques - Mrs.Akanksha Trivedi Rama UniversityAkanksha trivedi rama nursing college kanpur.
Natural birth techniques are various type such as/ water birth , alexender method, hypnosis, bradley method, lamaze method etcAzure Interview Questions and Answers PDF By ScholarHat
Azure Interview Questions and Answers PDF By ScholarHat
ANATOMY AND BIOMECHANICS OF HIP JOINT.pdf
it describes the bony anatomy including the femoral head , acetabulum, labrum . also discusses the capsule , ligaments . muscle that act on the hip joint and the range of motion are outlined. factors affecting hip joint stability and weight transmission through the joint are summarized.
DRUGS AND ITS classification slide share
Any substance (other than food) that is used to prevent, diagnose, treat, or relieve symptoms of a
disease or abnormal condition
The simplified electron and muon model, Oscillating Spacetime: The Foundation...
Discover the Simplified Electron and Muon Model: A New Wave-Based Approach to Understanding Particles delves into a groundbreaking theory that presents electrons and muons as rotating soliton waves within oscillating spacetime. Geared towards students, researchers, and science buffs, this book breaks down complex ideas into simple explanations. It covers topics such as electron waves, temporal dynamics, and the implications of this model on particle physics. With clear illustrations and easy-to-follow explanations, readers will gain a new outlook on the universe's fundamental nature.
A Survey of Techniques for Maximizing LLM Performance.pptx
A Survey of Techniques for Maximizing LLM Performance
CACJapan - GROUP Presentation 1- Wk 4.pdf
Macroeconomics- Movie Location
This will be used as part of your Personal Professional Portfolio once graded.
Objective:
Prepare a presentation or a paper using research, basic comparative analysis, data organization and application of economic information. You will make an informed assessment of an economic climate outside of the United States to accomplish an entertainment industry objective.
Advanced Java[Extra Concepts, Not Difficult].docx
This is part 2 of my Java Learning Journey. This contains Hashing, ArrayList, LinkedList, Date and Time Classes, Calendar Class and more.
The History of Stoke Newington Street Names
Presented at the Stoke Newington Literary Festival on 9th June 2024
www.StokeNewingtonHistory.com
Top five deadliest dog breeds in America
Thinking of getting a dog? Be aware that breeds like Pit Bulls, Rottweilers, and German Shepherds can be loyal and dangerous. Proper training and socialization are crucial to preventing aggressive behaviors. Ensure safety by understanding their needs and always supervising interactions. Stay safe, and enjoy your furry friends!
Recently uploaded (20)
Introduction to AI for Nonprofits with Tapp Network
Introduction to AI for Nonprofits with Tapp Network
South African Journal of Science: Writing with integrity workshop (2024)
South African Journal of Science: Writing with integrity workshop (2024)
How to Manage Your Lost Opportunities in Odoo 17 CRM
How to Manage Your Lost Opportunities in Odoo 17 CRM
Chapter 4 - Islamic Financial Institutions in Malaysia.pptx
Chapter 4 - Islamic Financial Institutions in Malaysia.pptx
Natural birth techniques - Mrs.Akanksha Trivedi Rama University
Natural birth techniques - Mrs.Akanksha Trivedi Rama University
Azure Interview Questions and Answers PDF By ScholarHat
Azure Interview Questions and Answers PDF By ScholarHat
Digital Artefact 1 - Tiny Home Environmental Design
Digital Artefact 1 - Tiny Home Environmental Design
The simplified electron and muon model, Oscillating Spacetime: The Foundation...
The simplified electron and muon model, Oscillating Spacetime: The Foundation...
A Survey of Techniques for Maximizing LLM Performance.pptx
A Survey of Techniques for Maximizing LLM Performance.pptx
lecture 26
- 1. CS 332: Algorithms Greedy Algorithms