We present an I O-efficient algorithm for computing similarity joins based on locality-sensitive hashing (LSH). In contrast to the filtering methods commonly suggested our method has provable sub-quadratic dependency on the data size. Further, in contrast to straightforward implementations of known LSH-based algorithms on external memory, our approach is able to take significant advantage of the available internal memory: Whereas the time complexity of classical algorithms includes a factor of @math , where @math is a parameter of the LSH used, the I O complexity of our algorithm merely includes a factor @math , where @math is the data size and @math is the size of internal memory. Our algorithm is randomized and outputs the correct result with high probability. It is a simple, recursive, cache-oblivious procedure, and we believe that it will be useful also in other computational settings such as parallel computation.
We study algorithms for similarity join in the , which has been widely adopted in the literature (see, e.g., the survey by Vitter @cite_22 ). The external memory model consists of an internal memory of @math words and an external memory of unbounded size. The processor can only access data stored in the internal memory and move data between the two memories in blocks of size @math . For simplicity we will here measure block and internal memory size in units of points from @math , such that they can contain @math points and @math points, respectively.
@cite_22
2072336782
A straight-line grid embedding of a planar graph is a drawing of the graph on a plane where the vertices are located at grid points and the edges are represented by nonintersecting segments of straight, lines joining their incident vertices. Given an n-vertex embedded planar graph with @math , a straight-line embedding on a grid of size @math can be computed deterministically in @math time with @math processors. If randomization is used, the complexity is improved to @math expected time with the same optimal linear work. These algorithms run on a parallel random access machine that allows concurrent reads and concurrent writes of the shared memory and permits an arbitrary processor to succeed in case of a write conflict.