
	Where results make sense

Topic: Divide and conquer algorithm

	Divide and conquer algorithm - Wikipedia, the free encyclopedia
		A divide and conquer algorithm is closely tied to a type of recurrence relation between functions of the data in question; data is "divided" into smaller portions and the result calculated thence.
		Divide and conquer is a powerful tool for solving conceptually difficult problems, such as the classic Tower of Hanoi puzzle: all it requires is a way of breaking the problem into sub-problems, of solving the trivial cases and of combining sub-problems to the original problem.
		Divide and conquer algorithms are naturally adapted for execution in multi-processor machines, especially shared-memory systems where the communication of data between processors does not need to be planned in advance, because distinct sub-problems can be executed on different processors....
	en.wikipedia.org /wiki/Divide_and_conquer_algorithm (1099 words)

	Divide-and-Conquer Algorithms
		Divides large instances to smaller ones, and (recursively) applies the algorithm on the smaller instances.
		Sets of cardinality greater than one are decomposed into two equal subsets, the algorithm is recursively invoked on the subsets, and the returned ordered subsets are merged to provide a sorted variant of the original set.
		Assume the greedy algorithm for the vertex cover problem uses a heap-based priority queue for selecting a node at each stage.
	www.cse.ohio-state.edu /~gurari/course/cis680/cis680Ch18.html (639 words)

	Algorithm Design Paradigms - Divide-and-Conquer (Site not responding. Last check: 2007-10-04)
		The answer to this question is central to the concept of Divide-&-Conquer algorithm and is a key factor in gauging their efficiency.
		The Divide-&-Conquer algorithm to solve this problem is the simplest example of the paradigm.
		It was observed earlier that one reason for examining algorithmic paradigms was the fact that their running time could often be precisely determined.
	www.csc.liv.ac.uk /~ped/teachadmin/algor/d_and_c.html (1637 words)

	Barnes-Hut Algorithm
		Divide and Conquer Algorithms are very popular for solving problems in an efficient means as well as for its pure simplicity.
		The algorithm in discussion is the Barnes-Hut algorithm, which is also a Divide and Conquer algorithm.
		The main use of the Barnes-Hut algorithm is calculating the distances apart that subjective particles are of a large assembly of particles.
	www.joegakenheimer.com /Gakenheimer/algorithms/barnes-hut.htm (582 words)

	Triangulation Algorithms and Data Structures
		Their results indicate a rough parity in speed among the incremental insertion algorithm of Lawson [11], the divide-and-conquer algorithm of Lee and Schachter [12], and the plane-sweep algorithm of Fortune [6]; however, the implementations they study were written by different people.
		The sweepline algorithm can easily detect duplicate points as they are removed from the event queue (by comparing each with the previous point removed from the queue), and the incremental insertion algorithm can detect a duplicate point after point location.
		Perhaps the most useful observation of this paper for practitioners is that the divide-and-conquer algorithm, the incremental algorithm, and the Delaunay refinement algorithm for mesh generation were all sped by a factor of two by the triangular data structure.
	www-2.cs.cmu.edu /~quake/tripaper/triangle2.html (1518 words)

	Divide and Conquer (Site not responding. Last check: 2007-10-04)
		Finally, the divide and conquer approach is very similar to the dynamic approach in that it divides the problem into subproblems and then solves them recursively, however, it solves problmes when subproblems are not independent of one another.
		Recall that basic idea of sequential Divide-and-Conquer algorithms is to solve the given problem directly, if it is small enough (i.e., if the problem is a base-case problem), otherwise divide it into several subproblems, find solutions to those subproblems and combine those solutions into the solutions to the given problem.
		Divide: divide the given problem into smaller independent subproblems of the same type as the given problem and solve them concurrently.
	home.wlu.edu /~whaleyt/classes/parallel/topics/dnc/dnc.html (395 words)

	Divide and Conquer
		Divide and conquer was a successful military strategy long before it became an algorithm design paradigm.
		To use divide and conquer as an algorithm design technique, we must divide the problem into two smaller subproblems, solve each of them recursively, and then meld the two partial solutions into one solution to the full problem.
		Divide and conquer is a design technique with many important algorithms to its credit, including mergesort, the fast Fourier transform, and Strassen's matrix multiplication algorithm.
	www2.toki.or.id /book/AlgDesignManual/BOOK/BOOK2/NODE53.HTM (231 words)

	Knecht: Parallelizing Divide-and-Conquer Algorithms - Microtasking versus Autotasking
		Algorithms based on a divide-and-conquer strategy are well qualified for being implemented in a multitasking environment.
		In this paper the parallel implementation of a divide-and-conquer algorithm to compute the convex hull in the plane is discussed.
		The algorithm is implemented in FORTRAN on a CRAY Y-MP8/832 using the CRAY multitasking strategies.
	www.fz-juelich.de /zam/docs/autoren90/knecht29 (172 words)

	CSC 321 Final exam
		Run your algorithm on the amounts 21¢, 54¢, and $5.33, listing the minimal number of coins needed for each.
		[Executing greedy graph-optimization algorithms] The following table represents an adjacency matrix for a graph on nine vertices, where the vertices are labeled with the letters 'a' through 'i'.
		Run Dijkstra's single-source shortest-path algorithm on the graph represented by the matrix using vertex a as the source.
	facweb.cs.depaul.edu /jrogers/csc321/FinalExam.htm (651 words)

	A Parallel Divide and Conquer Eigensolver
		The Divide and Conquer algorithm allows the solution of eigenproblems in a faster way than the usual QR and, more importantly, is easily suitable for parallelization.
		A major drawback of this algorithm was its instability in a few pathological cases where the orthogonality of the eigenvectors was not achieved.
		The Divide & Conquer method is based on reference [1] which used the rank-one modification algorithm found in [8].
	sawww.epfl.ch /SIC/SA/publications/SCR95/7-95-27a.html (1922 words)

	Merge Sort Algorithm
		The merge sort algorithm is said to be one of the earliest sorting algorithms created.
		The merge sort algorithm is a divide and conquer algorithm.
		As the battle rages on determining which sorting algorithm is the fastest, merge sort has shown to be one of the best.
	www2.hawaii.edu /~loganh/mergesort.html (880 words)

	Divide-and-conquer eigenvalue algorithm - Wikipedia, the free encyclopedia
		Divide-and-conquer eigenvalue algorithms are a class of eigenvalue algorithms for Hermitian or real symmetric matrices that have recently (circa 1990s) become competitive in terms of stability and efficiency with more traditional algorithms such as the QR algorithm.
		An eigenvalue problem is divided into two problems of roughly half the size, each of these are solved recursively, and the eigenvalues of the original problem are computed from the results of these smaller problems.
		As is common for divide and conquer algorithms, we will use the Master theorem to analyze the running time.
	en.wikipedia.org /wiki/Divide-and-conquer_eigenvalue_algorithm (906 words)

	Divide and Conquer (Site not responding. Last check: 2007-10-04)
		Divide and conquer algorithms are often implemented using recursion.
		However not all recursive functions are divide and conquer algorithm.
		Generally, the sub problems solved by divide and conquer algorithm are non overlapping
	www.cs.may.ie /~rosemary/se202/Mergesort/tsld003.htm (79 words)

	Lecture Outline (CMSC 754)
		The algorithm itself is similar to the sweep-line algorithm given in the text for trapezoidalization of simple polygons (except for edge crossings).
		The divide and conquer algorithm is quite simple, the main trick is in computing the upper and lower supporting lines.
		The main objective is to design an algorithm that navigates the robot between two points, among rectangular obstacles, such that the total path length traversed is not much longer than the true shortest path length between the start and the goal.
	www.cs.umd.edu /~samir/754/lecs.html (1871 words)

	The sequential and binary search
		Notice that the typical divide and conquer algorithm uses recursion to solve the subproblems independently.
		This variation differs from the standard divide and conquer technique because it "throws" out a portion of the problem when the problem is split.
		The actual algorithm does not construct the full tree but follows only a single branch until the element is found or a leaf node is reached.
	www.iwu.edu /~sander/CS255/Notes/binSearch.html (656 words)

	DivideAndConquer - PineWiki
		Divide and conquer is an algorithm design technique where we split a problem into to or more subproblems of approximately the same size.
		A typical divide and conquer algorithm has a running time given by a recurrence of the form
		Since most functions fit into one of these three cases, the cost of an even-split divide and conquer algorithm is largely determined by f(n).
	pine.cs.yale.edu /pinewiki/DivideAndConquer (109 words)

	A Serial Implementation of Cuppen's Divide and Conquer Algorithm for the Symmetric Eigenvalue Problem \| EECS at UC ...
		On a DEC Alpha using optimized Basic Linear Algebra Subroutines (BLAS), divide and conquer was uniformly the fastest algorithm by a large margin for large tridiagonal eigenproblems.
		Nearly universally, the matrix of eigenvectors generated by divide and conquer suffered the least loss of orthogonality.
		The smallest eigensystem residual usually came from the eigensystem generated by bisection/inverse iteration, with divide and conquer coming a close second.
	www.eecs.berkeley.edu /Pubs/TechRpts/1994/6315.html (294 words)

	Numerical and Related Functions
		Multiplication of large integers and high-precision approximate numbers is done using interleaved Karatsuba and FFT algorithms.
		uses the Jebelean-Weber accelerated GCD algorithm, together with a combination of Euclid's algorithm and an algorithm based on iterative removal of powers of 2.
		Algorithms similar to those of LINPACK, EISPACK and LAPACK are used when appropriate.
	documents.wolfram.com /teachersedition/MathematicaBook/A.9.4.html (948 words)

	A Generic Programming Concept Web -- 3.13 Generic Divide-and-Conquer Algorithm
		Divide the input into two or more (a finite number) of smaller inputs.
		Recursively apply the algorithm to each of the smaller inputs produced in the first step.
		This concept is one of many known ways of narrowing the generic algorithm concept in terms of a strategy, which gives a specific structure to the steps of the algorithm.
	www.cs.rpi.edu /~musser/concept-web/DivideAndConquerAlgorithm.html (142 words)

	Convex Hull of a 2D Point Set or Polygon
		This algorithm also applies to a polygon, or just a set of segments, whose hull is the same as the hull of its vertex point set.
		The algorithm is an inductive incremental procedure using a stack of points.
		The lower or upper convex chain is constructed using a stack algorithm almost identical to the one used for the Graham scan.
	geometryalgorithms.com /Archive/algorithm_0109/algorithm_0109.htm (2504 words)

	Divide and Conquer algorithm
		The divide-and-conquer algorithm is an algorithm for computing the convex hull of a set of points in two or more dimensions.
		Divide the points into two equal sized sets L and R such that all points of L are to the left of the most leftmost points in R. Recursively find the convex hull of L (shown in light blue) and R (shown in purple).
		The upper common tangent can be found in linear time by scanning around the left hull in a clockwise direction and around the right hull in an anti-clockwise direction.
	www.cse.unsw.edu.au /~lambert/java/3d/divideandconquer.html (591 words)

	Designing a new general-purpose language : Another motivating example for load-time configuration
		Therefore, it is common practice to use the divide and conquer algorithm down to a certain size, and then switch to the straightforward algorithm.
		Strassen's algorithm is divide and conquer, so it is possible to use it down to a certain size and then switch over.
		For example, there may be optimizations possible for the straightforward algorithm that depend on knowing the maximum size of the input.
	blogs.msdn.com /hartwil/archive/2006/05/04/590254.aspx (592 words)

	List of Abstracts
		The algorithm works by recursive application of a formula that constructs the articulated-body equations of motion of an assembly from those of its constituent parts.
		This paper is the second in a two-part series describing a recursive, divide-and-conquer algorithm for calculating the forward dynamics of a robot mechanism, or a general rigid-body system, on a parallel computer.
		Equations and algorithms are given for the most important dynamics computations, expressed in a common notation to facilitate their presentation and comparison.
	users.rsise.anu.edu.au /~roy/abstracts.html (1514 words)

	Closest Pair: A Divide-and-Conquer Approach
		Hence our full algorithm is not yet O(nlogn), but it is still an improvement on the quadratic performance of the brute force approach (as we shall see in the next section).
		The algorithm is simply written in list form because I find pseudo-code to be burdensome and unnecessary when trying to understand an algorithm.
		Divide the set into two equal sized parts by the line l, and recursively compute the minimal distance in each part.
	www.cs.mcgill.ca /~cs251/ClosestPair/ClosestPairDQ.html (1011 words)

	divide and conquer
		Note: The technique is named "divide and conquer" because a problem is conquered by dividing it into several smaller problems.
		The dividing part picks which segment to search, and "the solutions are combined" trivially: take the answer from the segment searched.
		Three divide and conquer sorting algorithms, as a means of using parallelism.
	www.nist.gov /dads/HTML/divideAndConquer.html (280 words)

	Sorting by divide-and-conquer
		This was an example of a sorting algorithm where one part used divide and conquer.
		According to Knuth, merge sort was one of the earliest sorting algorithms, invented by John von Neumann in 1945.
		Quicksort, invented by Tony Hoare, follows a very similar divide and conquer idea: partition into two lists and put them back together again It does more work on the divide side, less on the combine side.
	www.ics.uci.edu /~eppstein/161/960118.html (1693 words)

	A Divide-and-Conquer Algorithm for 3D Capacitance Extraction
		Our algorithm is a signi.cant improvement over the traditional BEMs and their enhancements, such as the "window" method where conductors far away are dropped, and the "shield" method where conductors hidden behind other conductors are dropped.
		Experimental results show that our algorithm is a magnitude faster than the traditional BEM and the window+shield method, for medium to large structures.
		The error of the capacitance computed by the new algorithm is within 2% for self capacitance and 7% for coupling capacitance, compared with the results obtained by solving the entire system using BEM.
	csdl.computer.org /comp/proceedings/isqed/2004/2093/00/20930253abs.htm (234 words)

	Running Time of Divide-and-Conquer Algorithms
		A number of divide-and-conquer algorithms are presented in the preceding sections.
		Because these algorithms have a similar form, the recurrences which give the running times of the algorithms are also similar in form.
		To solve an arbitrarily large problem using divide-and-conquer, the problem is divided into a number smaller problems, each of which is solved independently.
	www.brpreiss.com /books/opus5/html/page452.html (291 words)

Try your search on: Qwika (all wikis)