finding Min and max element from given array using divide & conquer
Download as ppt, pdf1 like4,045 views
This document discusses two methods for finding the maximum and minimum values in an array: the naive method and divide and conquer approach. The naive method compares all elements to find the max and min in 2n-2 comparisons. The divide and conquer approach recursively divides the array in half, finds the max and min of each half, and returns the overall max and min, reducing the number of comparisons. Pseudocode is provided for the MAXMIN algorithm that implements this divide and conquer solution.
1 of 7
Downloaded 41 times
![Find Max & Min element
Algorithm: Max-Min-Element (numbers[])
max := number[1]
min := number[1]
for i = 2 to n do
if number[i] > max then
max := number[i]
if number[i] < min then
min := number[i]
return (max, min)](https://image.slidesharecdn.com/minmaxdc-190227093311/85/finding-Min-and-max-element-from-given-array-using-divide-conquer-4-320.jpg)
![Function MAXMIN (A, low, high)
if (high − low + 1 = 2) then
if (A[low] < A[high]) then
max = A[high]; min = A[low]
return((max, min))
else
max = A[low]; min = A[high]
return((max, min))
end if
else
mid = low+high/2
(max_l , min_l ) = MAXMIN(A, low, mid)
(max_r , min_r ) =MAXMIN(A, mid + 1, high)
end if
Set max to the larger of max_l and max_r ;
set min to the smaller of min_l and min_r
return((max, min)).](https://image.slidesharecdn.com/minmaxdc-190227093311/85/finding-Min-and-max-element-from-given-array-using-divide-conquer-6-320.jpg)
![Function MAXMIN (A, low, high)
if (high − low + 1 = 2) then
if (A[low] < A[high]) then
max = A[high]; min = A[low]
return((max, min))
else
max = A[low]; min = A[high]
return((max, min))
end if
else
mid = low+high/2
(max_l , min_l ) = MAXMIN(A, low, mid)
(max_r , min_r ) =MAXMIN(A, mid + 1, high)
end if
Set max to the larger of max_l and max_r ;
set min to the smaller of min_l and min_r
return((max, min)).](https://image.slidesharecdn.com/minmaxdc-190227093311/85/finding-Min-and-max-element-from-given-array-using-divide-conquer-7-320.jpg)
Ad
Recommended
Unit 3 daa
Unit 3 daaNv Thejaswini This document discusses dynamic programming and algorithms for solving all-pair shortest path problems. It begins by explaining dynamic programming as an optimization technique that works bottom-up by solving subproblems once and storing their solutions, rather than recomputing them. It then presents Floyd's algorithm for finding shortest paths between all pairs of nodes in a graph. The algorithm iterates through nodes, updating the shortest path lengths between all pairs that include that node by exploring paths through it. Finally, it discusses solving multistage graph problems using forward and backward methods that work through the graph stages in different orders.
Divide and conquer - Quick sort
Divide and conquer - Quick sortMadhu Bala The document explains the divide and conquer strategy in algorithms, emphasizing its recursive nature and applications in sorting methods like quicksort and merge sort. Quicksort operates by partitioning arrays into smaller regions based on a pivot element to efficiently sort them. It outlines the algorithm's complexities, benefits, and techniques for choosing an effective pivot to enhance performance.
Lower bound
Lower boundRajendran This chapter discusses limitations on algorithmic power and methods for establishing lower bounds on algorithms. It introduces lower bounds as estimates of the minimum amount of work needed to solve a problem. Several methods are presented for establishing lower bounds, including trivial lower bounds based on input/output sizes, decision trees to model comparisons, adversary arguments, and reducing one problem to another with a known lower bound. Examples are given for sorting, searching, and matrix multiplication.
Shortest path algorithm
Shortest path algorithmSubrata Kumer Paul Dijkstra's algorithm is used to find the shortest paths from a source node to all other nodes in a network. It works by marking all nodes as tentative with initial distances from the source set to 0 and others to infinity. It then extracts the closest node, adds it to the shortest path tree, and relaxes distances of its neighbors. This process repeats until all nodes are processed. When applied to the example network, Dijkstra's algorithm finds the shortest path from node A to all others to be A-B=4, A-C=6, A-D=8, A-E=7, A-F=7, A-G=7, and A-H=9.
0/1 knapsack
0/1 knapsackAmin Omi The document discusses the 0-1 knapsack problem and how it can be solved using dynamic programming. It first defines the 0-1 knapsack problem and provides an example. It then explains how a brute force solution would work in exponential time. Next, it describes how to define the problem as subproblems and derive a recursive formula to solve the subproblems in a bottom-up manner using dynamic programming. This builds up the solutions in a table and solves the problem in polynomial time. Finally, it walks through an example applying the dynamic programming algorithm to a sample problem instance.
Unit 3 graph chapter6
Unit 3 graph chapter6DrkhanchanaR This document provides an overview of graphs and graph algorithms. It defines graphs, directed and undirected graphs, and graph terminology like vertices, edges, paths, cycles, connected components, and degrees. It describes different graph representations like adjacency matrices and adjacency lists. It also explains graph traversal algorithms like depth-first search and breadth-first search. Finally, it covers graph algorithms for finding minimum spanning trees, shortest paths, and transitive closure.
CLOSEST PAIR (Final)
CLOSEST PAIR (Final)Aruneel Das This document describes the closest pair problem and an efficient divide and conquer algorithm to solve it in O(n log n) time. The problem is to find the shortest distance between any two points in a set of n points. A naive O(n2) brute force approach compares all pairs of points. The divide and conquer approach partitions the points into halves, solves the subproblems recursively, and merges the results by checking at most 6 points within a rectangle region to find the closest pair between subsets.
Data Structures- Part5 recursion
Data Structures- Part5 recursionAbdullah Al-hazmy The document discusses recursion, including:
1) Recursion involves breaking a problem down into smaller subproblems until a base case is reached, then building up the solution to the overall problem from the solutions to the subproblems.
2) A recursive function is one that calls itself, with each call typically moving closer to a base case where the problem can be solved without recursion.
3) Recursion can be linear, involving one recursive call, or binary, involving two recursive calls to solve similar subproblems.
Divide and conquer
Divide and conquerDr Shashikant Athawale The document discusses divide and conquer algorithms. It describes divide and conquer as a design strategy that involves dividing a problem into smaller subproblems, solving the subproblems recursively, and combining the solutions. It provides examples of divide and conquer algorithms like merge sort, quicksort, and binary search. Merge sort works by recursively sorting halves of an array until it is fully sorted. Quicksort selects a pivot element and partitions the array into subarrays of smaller and larger elements, recursively sorting the subarrays. Binary search recursively searches half-intervals of a sorted array to find a target value.
Algorithm and pseudocode conventions
Algorithm and pseudocode conventionssaranyatdr The document discusses algorithms and pseudocode conventions. It defines an algorithm as a step-by-step procedure to solve a problem and get the desired output. Some key characteristics of algorithms are that they must be unambiguous, have well-defined inputs and outputs, terminate after a finite number of steps, and be feasible with available resources. Pseudocode is a notation for writing algorithms in a human-friendly way without ambiguity. The document provides conventions for writing pseudocode, such as using line numbers, proper indentation, assignment operators, array indexing, and flow control statements like if/else and for/while loops. It includes an example pseudocode for insertion sort following these conventions.
Asymptotic notations
Asymptotic notationsNikhil Sharma 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.
Np cooks theorem
Np cooks theoremNarayana Galla The document discusses the theory of NP-completeness. It begins by defining the complexity classes P, NP, NP-hard, and NP-complete. It then explains the concepts of reduction and how none of the NP-complete problems can be solved in polynomial time deterministically. The document provides examples of NP-complete problems like satisfiability (SAT), vertex cover, and the traveling salesman problem. It shows how nondeterministic algorithms can solve these problems and how they can be transformed into SAT instances. Finally, it proves that SAT is the first NP-complete problem by showing it is in NP and NP-hard.
Quick sort
Quick sortAfaq Mansoor Khan Quicksort is a divide and conquer algorithm that works by partitioning an array around a pivot value and recursively sorting the subarrays. It first selects a pivot element and partitions the array by moving all elements less than the pivot before it and greater elements after it. The subarrays are then recursively sorted through this process. When implemented efficiently with an in-place partition, quicksort is one of the fastest sorting algorithms in practice, with average case performance of O(n log n) time but worst case of O(n^2) time.
Lecture 14 run time environment
Lecture 14 run time environmentIffat Anjum The document discusses run-time environments and how compilers support program execution through run-time environments. It covers:
1) The compiler cooperates with the OS and system software through a run-time environment to implement language abstractions during execution.
2) The run-time environment handles storage layout/allocation, variable access, procedure linkage, parameter passing and interfacing with the OS.
3) Memory is typically divided into code, static storage, heap and stack areas, with the stack and heap growing towards opposite ends of memory dynamically during execution.
Graph coloring using backtracking
Graph coloring using backtrackingshashidharPapishetty This document summarizes graph coloring using backtracking. It defines graph coloring as minimizing the number of colors used to color a graph. The chromatic number is the fewest colors needed. Graph coloring is NP-complete. The document outlines a backtracking algorithm that tries assigning colors to vertices, checks if the assignment is valid (no adjacent vertices have the same color), and backtracks if not. It provides pseudocode for the algorithm and lists applications like scheduling, Sudoku, and map coloring.
Stressen's matrix multiplication
Stressen's matrix multiplicationKumar 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.
Forms of learning in ai
Forms of learning in aiRobert Antony Three main types of machine learning are supervised learning, unsupervised learning, and reinforcement learning. Supervised learning involves training a model using labeled input/output data where the desired outputs are provided, allowing the model to map inputs to outputs. Unsupervised learning involves discovering hidden patterns in unlabeled data and grouping similar data points together. Reinforcement learning involves an agent learning through trial-and-error interactions with a dynamic environment by receiving rewards or punishments for actions.
Breadth First Search & Depth First Search
Breadth First Search & Depth First SearchKevin Jadiya The document discusses two tree and graph traversal algorithms: Breadth First Search (BFS) and Depth First Search (DFS). BFS uses a queue to visit all nodes level by level, while DFS uses a stack to explore as far as possible along each branch before backtracking. It also compares the two algorithms in terms of speed, memory usage, and effectiveness in finding the shortest path.
Introduction to Dynamic Programming, Principle of Optimality
Introduction to Dynamic Programming, Principle of OptimalityBhavin Darji Dynamic programming is an optimization technique invented by Richard Bellman in 1950, designed to solve problems with overlapping subproblems by storing solutions to avoid recomputation. It involves characterizing the structure of optimal solutions, defining those solutions recursively, and computing the solutions either through top-down caching or a bottom-up approach. Applications of dynamic programming include problems like the knapsack problem, shortest path calculations, and matrix chain multiplication.
8 queens problem using back tracking
8 queens problem using back trackingTech_MX The document discusses solving the 8 queens problem using backtracking. It begins by explaining backtracking as an algorithm that builds partial candidates for solutions incrementally and abandons any partial candidate that cannot be completed to a valid solution. It then provides more details on the 8 queens problem itself - the goal is to place 8 queens on a chessboard so that no two queens attack each other. Backtracking is well-suited for solving this problem by attempting to place queens one by one and backtracking when an invalid placement is found.
Divide and Conquer
Divide and ConquerMelaku Bayih Demessie The document provides an analysis of divide-and-conquer algorithms, detailing their methodology of splitting problems into smaller sub-problems, solving them, and combining the solutions. It discusses several algorithms including binary search, finding minimum and maximum values, merge sort, quick sort, Strassen’s matrix multiplication, and convex hulls, emphasizing their recursive nature and efficiency. Each algorithm demonstrates how the divide-and-conquer strategy can improve performance in solving complex computational tasks.
Binary Search
Binary Searchkunj desai This document describes binary search and provides an example of how it works. It begins with an introduction to binary search, noting that it can only be used on sorted lists and involves comparing the search key to the middle element. It then provides pseudocode for the binary search algorithm. The document analyzes the time complexity of binary search as O(log n) in the average and worst cases. It notes the advantages of binary search are its efficiency, while the disadvantage is that the list must be sorted. Applications mentioned include database searching and solving equations.
Sum of subset problem.pptx
Sum of subset problem.pptxV.V.Vanniaperumal College for Women The document discusses the sum of subsets problem, which involves finding all subsets of positive integers that sum to a given number. It describes the problem, provides an example, and explains that backtracking can be used to systematically consider subsets. A pruned state space tree is shown for a sample problem to illustrate the backtracking approach. An algorithm for the backtracking solution to the sum of subsets problem is presented.
I. AO* SEARCH ALGORITHM
I. AO* SEARCH ALGORITHMvikas dhakane The AO* search algorithm is an informed search method utilized in artificial intelligence for solving problems through problem reduction using and-or graphs. This approach allows for the decomposition of complex problems into manageable sub-problems, fostering efficient path selection based on heuristic values. While AO* is complete and memory-efficient, it is not guaranteed to be optimal as it may not explore all potential paths once a solution is identified.
Divide and Conquer
Divide and ConquerDr Shashikant Athawale The document discusses the divide and conquer algorithm design paradigm. It begins by defining divide and conquer as recursively breaking down a problem into smaller sub-problems, solving the sub-problems, and then combining the solutions to solve the original problem. Some examples of problems that can be solved using divide and conquer include binary search, quicksort, merge sort, and the fast Fourier transform algorithm. The document then discusses control abstraction, efficiency analysis, and uses divide and conquer to provide algorithms for large integer multiplication and merge sort. It concludes by defining the convex hull problem and providing an example input and output.
Binary Search Tree in Data Structure
Binary Search Tree in Data StructureDharita Chokshi The document provides an overview of binary search trees (BST), detailing their structure, implementation, and core operations such as insertion, deletion, and traversal methods. It distinguishes between binary trees and binary search trees, emphasizing the rules that govern node value placements within a BST. Additionally, it discusses complexities involved in BST operations and mentions various types of trees, like red-black and AVL trees.
search strategies in artificial intelligence
search strategies in artificial intelligenceHanif Ullah (Gold Medalist) The document discusses search strategies in artificial intelligence. It defines key terms like search space, start state, goal test, and search tree. It describes properties of search algorithms like completeness, optimality, time complexity, and space complexity. It differentiates between uninformed searches, which do not use domain knowledge, like breadth-first search and depth-first search, and informed searches, which use heuristics to guide the search more efficiently, like greedy search and A* search. The document outlines the differences between informed and uninformed searches.
Red black tree
Red black treeRajendran The document discusses red-black trees, which are binary search trees augmented with node colors to guarantee a height of O(log n). It first defines the properties of red-black trees, then proves their height is O(log n), and finally describes insertion and deletion operations. The key points are that nodes can be red or black, insertion can violate properties so recoloring is needed, and rotations are used to restructure the tree during insertion and deletion while maintaining the red-black properties.
Report 01(MaxMin)
Report 01(MaxMin)Md. Bashartullah (Rabby) Md. Bashartullah submitted a report on January 26, 2016 to find the maximum and minimum numbers from a set using both the straight method and divide and conquer approach. The objective was to solve a problem using general and divide/conquer methods, implement algorithms to best solve the problem, and analyze data/outputs to find the best solution. The problem was to determine the maximum and minimum numbers from a set.
median and order statistics
median and order statisticsShashank Singh The document discusses order statistics such as the minimum, maximum, and median of a data set. It describes the selection problem of finding the ith smallest element. A naive solution is to sort the data, but a more efficient approach is presented to find the minimum and maximum in fewer than 2n-2 comparisons by processing elements in pairs. The randomized selection algorithm is then described to find the ith smallest element in expected linear time by partitioning the data around a randomly chosen pivot.
More Related Content
What's hot (20)
Divide and conquer
Divide and conquerDr Shashikant Athawale The document discusses divide and conquer algorithms. It describes divide and conquer as a design strategy that involves dividing a problem into smaller subproblems, solving the subproblems recursively, and combining the solutions. It provides examples of divide and conquer algorithms like merge sort, quicksort, and binary search. Merge sort works by recursively sorting halves of an array until it is fully sorted. Quicksort selects a pivot element and partitions the array into subarrays of smaller and larger elements, recursively sorting the subarrays. Binary search recursively searches half-intervals of a sorted array to find a target value.
Algorithm and pseudocode conventions
Algorithm and pseudocode conventionssaranyatdr The document discusses algorithms and pseudocode conventions. It defines an algorithm as a step-by-step procedure to solve a problem and get the desired output. Some key characteristics of algorithms are that they must be unambiguous, have well-defined inputs and outputs, terminate after a finite number of steps, and be feasible with available resources. Pseudocode is a notation for writing algorithms in a human-friendly way without ambiguity. The document provides conventions for writing pseudocode, such as using line numbers, proper indentation, assignment operators, array indexing, and flow control statements like if/else and for/while loops. It includes an example pseudocode for insertion sort following these conventions.
Asymptotic notations
Asymptotic notationsNikhil Sharma 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.
Np cooks theorem
Np cooks theoremNarayana Galla The document discusses the theory of NP-completeness. It begins by defining the complexity classes P, NP, NP-hard, and NP-complete. It then explains the concepts of reduction and how none of the NP-complete problems can be solved in polynomial time deterministically. The document provides examples of NP-complete problems like satisfiability (SAT), vertex cover, and the traveling salesman problem. It shows how nondeterministic algorithms can solve these problems and how they can be transformed into SAT instances. Finally, it proves that SAT is the first NP-complete problem by showing it is in NP and NP-hard.
Quick sort
Quick sortAfaq Mansoor Khan Quicksort is a divide and conquer algorithm that works by partitioning an array around a pivot value and recursively sorting the subarrays. It first selects a pivot element and partitions the array by moving all elements less than the pivot before it and greater elements after it. The subarrays are then recursively sorted through this process. When implemented efficiently with an in-place partition, quicksort is one of the fastest sorting algorithms in practice, with average case performance of O(n log n) time but worst case of O(n^2) time.
Lecture 14 run time environment
Lecture 14 run time environmentIffat Anjum The document discusses run-time environments and how compilers support program execution through run-time environments. It covers:
1) The compiler cooperates with the OS and system software through a run-time environment to implement language abstractions during execution.
2) The run-time environment handles storage layout/allocation, variable access, procedure linkage, parameter passing and interfacing with the OS.
3) Memory is typically divided into code, static storage, heap and stack areas, with the stack and heap growing towards opposite ends of memory dynamically during execution.
Graph coloring using backtracking
Graph coloring using backtrackingshashidharPapishetty This document summarizes graph coloring using backtracking. It defines graph coloring as minimizing the number of colors used to color a graph. The chromatic number is the fewest colors needed. Graph coloring is NP-complete. The document outlines a backtracking algorithm that tries assigning colors to vertices, checks if the assignment is valid (no adjacent vertices have the same color), and backtracks if not. It provides pseudocode for the algorithm and lists applications like scheduling, Sudoku, and map coloring.
Stressen's matrix multiplication
Stressen's matrix multiplicationKumar 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.
Forms of learning in ai
Forms of learning in aiRobert Antony Three main types of machine learning are supervised learning, unsupervised learning, and reinforcement learning. Supervised learning involves training a model using labeled input/output data where the desired outputs are provided, allowing the model to map inputs to outputs. Unsupervised learning involves discovering hidden patterns in unlabeled data and grouping similar data points together. Reinforcement learning involves an agent learning through trial-and-error interactions with a dynamic environment by receiving rewards or punishments for actions.
Breadth First Search & Depth First Search
Breadth First Search & Depth First SearchKevin Jadiya The document discusses two tree and graph traversal algorithms: Breadth First Search (BFS) and Depth First Search (DFS). BFS uses a queue to visit all nodes level by level, while DFS uses a stack to explore as far as possible along each branch before backtracking. It also compares the two algorithms in terms of speed, memory usage, and effectiveness in finding the shortest path.
Introduction to Dynamic Programming, Principle of Optimality
Introduction to Dynamic Programming, Principle of OptimalityBhavin Darji Dynamic programming is an optimization technique invented by Richard Bellman in 1950, designed to solve problems with overlapping subproblems by storing solutions to avoid recomputation. It involves characterizing the structure of optimal solutions, defining those solutions recursively, and computing the solutions either through top-down caching or a bottom-up approach. Applications of dynamic programming include problems like the knapsack problem, shortest path calculations, and matrix chain multiplication.
8 queens problem using back tracking
8 queens problem using back trackingTech_MX The document discusses solving the 8 queens problem using backtracking. It begins by explaining backtracking as an algorithm that builds partial candidates for solutions incrementally and abandons any partial candidate that cannot be completed to a valid solution. It then provides more details on the 8 queens problem itself - the goal is to place 8 queens on a chessboard so that no two queens attack each other. Backtracking is well-suited for solving this problem by attempting to place queens one by one and backtracking when an invalid placement is found.
Divide and Conquer
Divide and ConquerMelaku Bayih Demessie The document provides an analysis of divide-and-conquer algorithms, detailing their methodology of splitting problems into smaller sub-problems, solving them, and combining the solutions. It discusses several algorithms including binary search, finding minimum and maximum values, merge sort, quick sort, Strassen’s matrix multiplication, and convex hulls, emphasizing their recursive nature and efficiency. Each algorithm demonstrates how the divide-and-conquer strategy can improve performance in solving complex computational tasks.
Binary Search
Binary Searchkunj desai This document describes binary search and provides an example of how it works. It begins with an introduction to binary search, noting that it can only be used on sorted lists and involves comparing the search key to the middle element. It then provides pseudocode for the binary search algorithm. The document analyzes the time complexity of binary search as O(log n) in the average and worst cases. It notes the advantages of binary search are its efficiency, while the disadvantage is that the list must be sorted. Applications mentioned include database searching and solving equations.
Sum of subset problem.pptx
Sum of subset problem.pptxV.V.Vanniaperumal College for Women The document discusses the sum of subsets problem, which involves finding all subsets of positive integers that sum to a given number. It describes the problem, provides an example, and explains that backtracking can be used to systematically consider subsets. A pruned state space tree is shown for a sample problem to illustrate the backtracking approach. An algorithm for the backtracking solution to the sum of subsets problem is presented.
I. AO* SEARCH ALGORITHM
I. AO* SEARCH ALGORITHMvikas dhakane The AO* search algorithm is an informed search method utilized in artificial intelligence for solving problems through problem reduction using and-or graphs. This approach allows for the decomposition of complex problems into manageable sub-problems, fostering efficient path selection based on heuristic values. While AO* is complete and memory-efficient, it is not guaranteed to be optimal as it may not explore all potential paths once a solution is identified.
Divide and Conquer
Divide and ConquerDr Shashikant Athawale The document discusses the divide and conquer algorithm design paradigm. It begins by defining divide and conquer as recursively breaking down a problem into smaller sub-problems, solving the sub-problems, and then combining the solutions to solve the original problem. Some examples of problems that can be solved using divide and conquer include binary search, quicksort, merge sort, and the fast Fourier transform algorithm. The document then discusses control abstraction, efficiency analysis, and uses divide and conquer to provide algorithms for large integer multiplication and merge sort. It concludes by defining the convex hull problem and providing an example input and output.
Binary Search Tree in Data Structure
Binary Search Tree in Data StructureDharita Chokshi The document provides an overview of binary search trees (BST), detailing their structure, implementation, and core operations such as insertion, deletion, and traversal methods. It distinguishes between binary trees and binary search trees, emphasizing the rules that govern node value placements within a BST. Additionally, it discusses complexities involved in BST operations and mentions various types of trees, like red-black and AVL trees.
search strategies in artificial intelligence
search strategies in artificial intelligenceHanif Ullah (Gold Medalist) The document discusses search strategies in artificial intelligence. It defines key terms like search space, start state, goal test, and search tree. It describes properties of search algorithms like completeness, optimality, time complexity, and space complexity. It differentiates between uninformed searches, which do not use domain knowledge, like breadth-first search and depth-first search, and informed searches, which use heuristics to guide the search more efficiently, like greedy search and A* search. The document outlines the differences between informed and uninformed searches.
Red black tree
Red black treeRajendran The document discusses red-black trees, which are binary search trees augmented with node colors to guarantee a height of O(log n). It first defines the properties of red-black trees, then proves their height is O(log n), and finally describes insertion and deletion operations. The key points are that nodes can be red or black, insertion can violate properties so recoloring is needed, and rotations are used to restructure the tree during insertion and deletion while maintaining the red-black properties.
Similar to finding Min and max element from given array using divide & conquer (20)
Report 01(MaxMin)
Report 01(MaxMin)Md. Bashartullah (Rabby) Md. Bashartullah submitted a report on January 26, 2016 to find the maximum and minimum numbers from a set using both the straight method and divide and conquer approach. The objective was to solve a problem using general and divide/conquer methods, implement algorithms to best solve the problem, and analyze data/outputs to find the best solution. The problem was to determine the maximum and minimum numbers from a set.
median and order statistics
median and order statisticsShashank Singh The document discusses order statistics such as the minimum, maximum, and median of a data set. It describes the selection problem of finding the ith smallest element. A naive solution is to sort the data, but a more efficient approach is presented to find the minimum and maximum in fewer than 2n-2 comparisons by processing elements in pairs. The randomized selection algorithm is then described to find the ith smallest element in expected linear time by partitioning the data around a randomly chosen pivot.
Divide and conquer
Divide and conquerramya marichamy Divide and conquer is a general algorithm design paradigm where a problem is divided into subproblems, the subproblems are solved independently, and the results are combined to solve the original problem. Binary search is a divide and conquer algorithm that searches for a target value in a sorted array by repeatedly dividing the search interval in half. It compares the target to the middle element of the array, and then searches either the upper or lower half depending on whether the target is greater or less than the middle element. Finding the maximum and minimum elements in an array can also be solved using divide and conquer by recursively finding the max and min of halves of the array and combining the results.
Lec34
Lec34Nikhil Chilwant The document discusses the divide and conquer algorithm design paradigm. It provides examples of using divide and conquer to solve problems like sorting a list, finding the minimum element, and tiling a defective chessboard. The key steps of the divide and conquer approach are to (1) divide the problem into subproblems, (2) solve the subproblems, and (3) combine the solutions to solve the original problem.
algorithm Unit 2
algorithm Unit 2 Monika Choudhery 1) The document describes the divide-and-conquer algorithm design paradigm. It splits problems into smaller subproblems, solves the subproblems recursively, and then combines the solutions to solve the original problem.
2) Binary search is provided as an example algorithm that uses divide-and-conquer. It divides the search space in half at each step to quickly determine if an element is present.
3) Finding the maximum and minimum elements in an array is another problem solved using divide-and-conquer. It recursively finds the max and min of halves of the array and combines the results.
Unit 2 in daa
Unit 2 in daaNv Thejaswini 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.
Minimax Algorithm
Minimax Algorithm sulaiman_karim The minimax algorithm is used to determine the best possible move for a player in two-player zero-sum games like chess. It works by having each player assume their opponent will make the best counter-move. The algorithm searches the game tree by alternately maximizing and minimizing at each level to assign a value to leaf nodes, then backing up values towards the root. This process determines the move with the highest minimum value from the player's perspective.
Project management
Project managementAvay Minni The document describes using a genetic algorithm to solve resource-constrained project scheduling problems. It introduces genetic algorithms and describes how they can be applied to optimization problems. It then formulates a sample resource-constrained project scheduling problem as a linear programming problem to find basic feasible solutions and extreme points. The conclusion states that future work will use genetic algorithm operators like selection, reproduction and evaluation on the feasible solutions to find an optimal schedule.
Algorithm in computer science
Algorithm in computer scienceRiazul Islam The document discusses divide and conquer algorithms. It explains that divide and conquer algorithms work by dividing problems into smaller subproblems, solving the subproblems independently, and then combining the solutions to solve the original problem. An example of finding the minimum and maximum elements in an array using divide and conquer is provided, with pseudocode. Advantages of divide and conquer algorithms include solving difficult problems and often finding efficient solutions.
270-102-divide-and-conquer_handout.pdfCS 270Algorithm.docx
270-102-divide-and-conquer_handout.pdfCS 270Algorithm.docxeugeniadean34240 The document discusses the growth of functions and the divide-and-conquer algorithm, focusing on the min-max problem in algorithm analysis. It covers key concepts like big-O notation, examples of asymptotic notations, and details how to compute minimum and maximum values efficiently using the divide-and-conquer strategy. Additionally, it analyzes the performance of the min-max algorithm through recursion and presents optimizations for comparison counts.
Lecture 8 dynamic programming
Lecture 8 dynamic programmingOye Tu This document discusses algorithms for finding minimum and maximum elements in an array, including simultaneous minimum and maximum algorithms. It introduces dynamic programming as a technique for improving inefficient divide-and-conquer algorithms by storing results of subproblems to avoid recomputing them. Examples of dynamic programming include calculating the Fibonacci sequence and solving an assembly line scheduling problem to minimize total time.
Matlab tutorial 2
Matlab tutorial 2Norhan Abdalla MATLAB Tutorial 2 provides an overview of built-in MATLAB functions across several categories: math functions, complex numbers, matrices algebra, plotting, and data analysis. It includes examples of using functions to find absolute values, square roots, logarithms, factors, and other operations. It also demonstrates how to perform matrix operations like inverses, determinants, and special matrices. The document shows how to create basic and advanced plots, including polar, 3D, and subplot graphs.
Operations Research - The Big M Method
Operations Research - The Big M MethodHisham Al Kurdi, EAVA, DMC-D-4K, HCCA-P, HCAA-D The Big M Method is used to solve linear programming problems with inequality constraints. It involves multiplying inequality constraints to make the right hand side positive, introducing surplus and slack variables, and adding a large penalty term M to the objective for any artificial variables. The example problem is solved using this method in multiple iterations of the simplex algorithm to find the optimal solution.
9 Multi criteria Operation Decision Making - Nov 16 2020. pptx (ver2).pptx
9 Multi criteria Operation Decision Making - Nov 16 2020. pptx (ver2).pptxdnbtraniemyu This document discusses multiple objective decision making (MODM). It begins by introducing MODM and noting that it involves optimizing multiple conflicting objectives simultaneously through compromise. The document then covers modeling MODM problems mathematically and classifying solution types as optimal, efficient, or ideal. It also presents techniques for solving MODM problems, including the global criterion method. An example of using the global criterion method to formulate and solve a production scheduling problem is provided to illustrate the process.
Min and max search
Min and max searchKumar This document discusses algorithms for finding the minimum and maximum values in an array. It describes an O(n) algorithm for finding the minimum value that iterates through the array and tracks the smallest element. A similar algorithm can find the maximum value. It also presents an algorithm that finds both the minimum and maximum in an array in 3n/2 comparisons by recursively dividing the array in half and combining results.
Dynamic_methods_Greedy_algorithms_11.ppt
Dynamic_methods_Greedy_algorithms_11.pptGautam873893 The document discusses optimization problems, focusing on dynamic programming (DP) and greedy algorithms. It details the elements of DP, such as sub-structure, table-structure, and bottom-up computation, emphasizing their application in matrix-chain multiplication and the longest common subsequence. It also outlines the recursive solutions and the principles that guide the optimal structuring of such problems to minimize computational overhead.
Gauss Elimination (With Partial Pivot)
Gauss Elimination (With Partial Pivot)Saloni Singhal 1. The document describes writing an M-file to implement Gauss elimination method with partial pivoting to solve systems of linear equations. It includes both script and function files for the program.
2. The theory of Gauss elimination with partial pivoting is explained, including choosing the largest pivot element, row interchange, forward and backward substitution to put the matrix in row echelon form.
3. Advantages of partial pivoting include adequately reducing round-off error and saving time/storage space for sparse matrices. The time complexity of the algorithm is O(n^3).
Lop1
Lop1devendragiitk This document discusses greedy algorithms and divide and conquer algorithms. It provides examples of problems that can be solved using each approach and outlines the general solutions. For greedy algorithms, it explains that they make locally optimal choices at each step without considering future possibilities. For divide and conquer, it explains the three main steps of dividing the problem into subproblems, solving the subproblems recursively, and merging the solutions. It also provides an example problem of finding the number of inversions in an array by modifying the merge sort algorithm.
Amth250 octave matlab some solutions (4)
Amth250 octave matlab some solutions (4)asghar123456 This document provides the solutions to assignment questions about linear algebra and linear programming. It includes:
1) The matrix and vector representations of a system of linear equations. It finds the numerical solution and compares it to the exact solution.
2) An analysis of the condition number of Hilbert matrices of increasing size, showing the condition number grows exponentially up to a certain point.
3) Formulating a production planning problem as a linear programming problem to maximize profit subject to resource constraints. It solves the problem as both a linear program and integer program.
14-dynamic-programming-work-methods.pptx
14-dynamic-programming-work-methods.pptxr6s0069 The document is a lecture on dynamic programming techniques, specifically focusing on problems such as the weighted interval scheduling and rod cutting. It outlines a step-by-step approach for formulating problems, designing algorithms, proving correctness, and analyzing running times using recursive and iterative methods. The lecture emphasizes the importance of identifying subproblems and transitioning from a recursive algorithm to an optimal iterative solution.
Ad
Recently uploaded (20)
Fundamentals of Digital Design_Class_12th April.pptx
Fundamentals of Digital Design_Class_12th April.pptxdrdebarshi1993 Boolean Algebra and Combinational Logic Circuit
Introduction to Natural Language Processing - Stages in NLP Pipeline, Challen...
Introduction to Natural Language Processing - Stages in NLP Pipeline, Challen...resming1 Lecture delivered in 2021. This gives an introduction to Natural Language Processing. It describes the use cases of NLP in daily life. It discusses the stages in NLP Pipeline. It highlights the challenges involved covering the different levels of ambiguity that could arise. It also gives a brief note on the present scenario with the latest language models, tools and frameworks/libraries for NLP.
Cadastral Maps
Cadastral MapsGoogle Preparation of cadastral maps based by Engineer Dungo Tizazu from Dire Dawa University
Complete guidance book of Asp.Net Web API
Complete guidance book of Asp.Net Web APIShabista Imam Unlock the full potential of modern web development with the Complete Guidance Book of ASP.NET Web API—your all-in-one resource for mastering RESTful services using Microsoft’s powerful ASP.NET Core framework. This book takes you on a step-by-step journey from beginner to expert, covering everything from routing and controllers to security, performance optimization, and real-world architecture.
Stay Safe Women Security Android App Project Report.pdf
Stay Safe Women Security Android App Project Report.pdfKamal Acharya Women’s security is a critical issue in today’s world and it’s very much needed for every individual
to be acting over such an issue. This document describes a GPS based “Women Security System''
that provides the combination of GPS devices as well as provide alerts and messages with an
emergency button trigger whenever somebody is in trouble They might not have so much time, all
that they have to do is generate a distress emergency signal by shaking up their phone. Our system
provides a realizable, cost effective solution to problem detection. Nowdays due to recently
happened cases such as rape by drivers or colleagues, burglary etc., women security, especially
women security has become the foremost priority of the world. System uses the Global Positioning
System (GPS) technology to find out the location of women. The information of women's position
provided by the device can be viewed on Google maps using Internet or specialized software. The
companies are looking for-ward to the security problem and require a system that will efficiently
evaluate the problem of women security working in night shifts, traveling alone. We focus on the
proposed model that can be used to deal with the security issue of women using GPS based tracking
systems.
May 2025: Top 10 Read Articles in Data Mining & Knowledge Management Process
May 2025: Top 10 Read Articles in Data Mining & Knowledge Management ProcessIJDKP Data mining and knowledge discovery in databases have been attracting a significant amount of research, industry, and media attention of late. There is an urgent need for a new generation of computational theories and tools to assist researchers in extracting useful information from the rapidly growing volumes of digital data.
This Journal provides a forum for researchers who address this issue and to present their work in a peer-reviewed open access forum. Authors are solicited to contribute to the Journal by submitting articles that illustrate research results, projects, surveying works and industrial experiences that describe significant advances in the following areas, but are not limited to these topics only.
International Journal of Advanced Information Technology (IJAIT)
International Journal of Advanced Information Technology (IJAIT)ijait International journal of advanced Information technology (IJAIT) is a bi monthly open access peer-
reviewed journal, will act as a major forum for the presentation of innovative ideas, approaches,
developments, and research projects in the area advanced information technology applications and
services. It will also serve to facilitate the exchange of information between researchers and industry
professionals to discuss the latest issues and advancement in the area of advanced IT. Core areas of
advanced IT and multi-disciplinary and its applications will be covered during the conferences.
Decoding Kotlin - Your Guide to Solving the Mysterious in Kotlin - Devoxx PL ...
Decoding Kotlin - Your Guide to Solving the Mysterious in Kotlin - Devoxx PL ...João Esperancinha Kotlin can be very handy and easy to use. Kotlin offers the possibility to develop code that is easy to understand, safe, immutable, and thus predictable and follows standards that avoid side effects. I realized that very quickly after I started my Kotlin journey that already amounts to more than 5 years.
This is the third version of this presentation focused on more detail explaining inline, crossinline, tailrec and as a bonus a quick run through unnamed classes.
Deep Learning for Image Processing on 16 June 2025 MITS.pptx
Deep Learning for Image Processing on 16 June 2025 MITS.pptxresming1 This covers how image processing or the field of computer vision has advanced with the advent of neural network architectures ranging from LeNet to Vision transformers. It covers how deep neural network architectures have developed step-by-step from the popular CNNs to ViTs. CNNs and its variants along with their features are described. Vision transformers are introduced and compared with CNNs. It also shows how an image is processed to be given as input to the vision transformer. It give the applications of computer vision.
How to Un-Obsolete Your Legacy Keypad Design
How to Un-Obsolete Your Legacy Keypad DesignEpec Engineered Technologies For any number of circumstances, obsolescence risk is ever present in the electronics industry. This is especially true for human-to-machine interface hardware, such as keypads, touchscreens, front panels, bezels, etc. This industry is known for its high mix and low-volume builds, critical design requirements, and high costs to requalify hardware. Because of these reasons, many programs will face end-of-life challenges both at the component level as well as at the supplier level.
Redesigns and qualifications can take months or even years, so proactively managing this risk is the best way to deter this. If an LED is obsolete or a switch vendor has gone out of business, there are options to proceed.
In this webinar, we cover options to redesign and reverse engineer legacy keypad and touchscreen designs.
For more information on our HMI solutions, visit https://www.epectec.com/user-interfaces.
FUNDAMENTALS OF COMPUTER ORGANIZATION AND ARCHITECTURE
FUNDAMENTALS OF COMPUTER ORGANIZATION AND ARCHITECTUREShabista Imam FUNDAMENTALS OF COMPUTER ORGANIZATION AND ARCHITECTURE
By : Mostafa Abd-El-Barr & Hesham El-Rewini:: wiley
A complete guidance book
Proposal for folders structure division in projects.pdf
Proposal for folders structure division in projects.pdfMohamed Ahmed Proposal for folders structure division in projects
(Continuous Integration and Continuous Deployment/Delivery) is a fundamental ...
(Continuous Integration and Continuous Deployment/Delivery) is a fundamental ...ketan09101 (Continuous Integration and Continuous Deployment/Delivery) is a fundamental practice in DevOps that streamlines software development and deployment.
Ad
finding Min and max element from given array using divide & conquer
- 1. Finding Min,Max element from array Using Divide & Conquer By: S. A. Jaipurkar Asst. Prof. MIT, Aurangabad. Maharashtra.
- 2. Finding Min,Max element from array Using Divide & Conquer Consider a simple problem that can be solved by divide and conquer technique. The Max-Min Problem in algorithm analysis: finding the maximum and minimum value in an array. Solution : 2 methods : 1. naive method 2. divide and conquer approach
- 3. Naïve Method It is a basic method to solve any problem. In this method, the maximum and minimum number can be found separately. To find the maximum and minimum numbers, the following straightforward algorithm can be used. Analysis : The number of comparison in Naive method is 2n - 2. The number of comparisons can be reduced using the divide and conquer approach.
- 4. Find Max & Min element Algorithm: Max-Min-Element (numbers[]) max := number[1] min := number[1] for i = 2 to n do if number[i] > max then max := number[i] if number[i] < min then min := number[i] return (max, min)
- 5. Divide and Conquer Approach In this approach, the array is divided into two halves. Then using recursive approach maximum and minimum numbers in each halves are found. Later, return the maximum of two maxima of each half and the minimum of two minima of each half.
- 6. Function MAXMIN (A, low, high) if (high − low + 1 = 2) then if (A[low] < A[high]) then max = A[high]; min = A[low] return((max, min)) else max = A[low]; min = A[high] return((max, min)) end if else mid = low+high/2 (max_l , min_l ) = MAXMIN(A, low, mid) (max_r , min_r ) =MAXMIN(A, mid + 1, high) end if Set max to the larger of max_l and max_r ; set min to the smaller of min_l and min_r return((max, min)).
- 7. Function MAXMIN (A, low, high) if (high − low + 1 = 2) then if (A[low] < A[high]) then max = A[high]; min = A[low] return((max, min)) else max = A[low]; min = A[high] return((max, min)) end if else mid = low+high/2 (max_l , min_l ) = MAXMIN(A, low, mid) (max_r , min_r ) =MAXMIN(A, mid + 1, high) end if Set max to the larger of max_l and max_r ; set min to the smaller of min_l and min_r return((max, min)).