Transform & Conquer

By -

Transform & Conquer

Definition

Transform & Conquer is a general algorithm design technique which works in two stages.

STAGE 1: (Transformation stage): The problem’s instance is modified, more amenable to solution

STAGE 2: (Conquering stage): The transformed problem is solved

The three major variations of the transform & conquer differ by the way a given instance is transformed:

1. INSTANCE SIMPLIFICATION: Transformation of an instance of a problem to an instance of the same problem with some special property that makes the problem easier to solve.

Example: list pre-sorting, AVL trees

2. REPRESENTATION CHANGE: Changing one representation of a problem’s instance into another representation of the same instance.

Example: 2-3 trees, heaps and heapsort

3. PROBLEM REDUCTION: Transforming a problem given to another problem that can be solved by a known algorithm.

Example: reduction to graph problems, reduction to linear programming

Presorting

• Presorting is an example for instance simplification.

• Many questions about lists are easier to answer if the lists are sorted.

• Time efficiency of the problem’s algorithm is dominated by the algorithm used for sorting the list.

NOTE:

No comparison based sorting algorithm can has a better efficiency than nlogn in the worst case

Example: Problem of checking element uniqueness in an array:

• Limitation of brute-force algorithm:

Compares pairs of the array’s elements until either two equal elements are found or no more pairs were left. Worst case efficiency = Θ(n2)

• Using presorting:

Presorting helps to sort the array first and then check only its consecutive elements: if the array has equal elements, a pair of them must be next to each other

ALGORITHM PresortElementUniqueness( a[0…n-1])

//solves the element uniqueness problem by sorting the array first

//i/p: An array A of orderable elements

//o/p: Returns “true” if A has no equal elements, “false” otherwise

image

Analysis:

• Input size: n – array size

• Basic operation: key comparison

• Running time = sum of the time spent on sorting AND time spent on checking consecutive elements.

Therefore:

image

Example: Searching problem

• Brute-force solution:

Sequential search using brute-force methods needs n comparisons in the worst case, Worst case efficiency = Θ(n)

• Using presorting:

Presorting sorts the array first and then even if binary search is applied to search the key, the running time is:

Running time = time required to sort the array + time required to search the key using binary search

image

NOTE:

Using presorting, the solution is inferior to sequential search using brute force. BUT if the list is searched many number of times, then presorting is advantageous.

Comments

Post a Comment

Popular posts from this blog

Data Structure Visualization:Introduction and Value of Data Structure Rendering

By -
Introduction Important advances in programming languages have occurred since the early days of assembly languages and op codes, and modern programming languages have significantly simplified the task of writing computer programs. Unfortunately, tools for un d e rstanding programs have not achieved the accompanying levels of improvement. Software developers still face difficulties in understanding, analyzing, debugging, and improving code. As an example of the difficulties still evident, consider a developer who has just implemented a new algorithm and is now ready to examine the program’s behavior. After issuing a command to begin program execution, the developer examines output data and/or inter- active behavior, attempting to ascertain if the program functioned correctly, and if not, the reasons for the program’s failure. This task can be laborious and usually requires the use of a debugger or perhaps even the addition of explicit checking code, usually through output statements. Furt
Read more

Binary Space Partitioning Trees:BSP Tree as a Hierarchy of Regions.

By -
Image
BSP Tree as a Hierarchy of Regions Another way to look at BSP Trees is to focus on the hierarchy of regions created by the recursive partitioning, instead of focusing on the hyperplanes themselves. This view helps us to see more easily how intersections are efficiently computed. The key idea is to think of a BSP Tree region as serving as a bounding volume: each node v corresponds to a convex volume that completely contains all the geometry represented by the sub tree rooted at v . Therefore, if some other geometric entity, such as a point, ray, object, etc., is found to not intersect the bounding volume, then no intersection computations need be performed with any geometry within that volume. Consider as an example a situation in which we are given some test point and we want to find which object if any this point lies in. Initially, we know only that the point lies somewhere space ( Figure 20.12). By comparing the location of the point with respect to the first partitioning hyper pl
Read more

Drawing Trees:HV-Layout

By -
Image
HV-Layout An hv -layout of a binary tree is an upward (but not strictly upward) straight line orthogonal drawing with edges drawn as rightward horizontal or downward vertical segments. The ”hv” stands for horizontal-vertical. For any vertex v in a binary tree T we either have: 1. A child of v is either • aligned horizontally with v and to the right of v or • vertically aligned below v . 2. The smallest rectangles that cover the area of the subtrees of the children of v in the layout do not intersect. Figure 45.12 shows an example of a hv -layout A hv -layout is generated by applying a dived and conquer approach. The divide step constructs the hv -layout of the left and the right subtrees, while the conquer step either performs a ho rizontal or a ver t i c a l combination . Figure 45.13 shows the two types of com- bination. If the left subtree a node v is placed to the left in a horizontal combination and below in a vertical combination, the layout preserves
Read more