## A memory-efficient data structure representing exact-match overlap graphs with application for next-generation DNA assembly

**Motivation:**Exact-match overlap graphs have been broadly used in the context of DNA assembly and the

*shortest super string problem*where the number of strings

*n*ranges from thousands to billions. The length of the strings is from 25 to 1000, depending on the DNA sequencing technologies. However, many DNA assemblers using overlap graphs suffer from the need for too much time and space in constructing the graphs. It is nearly impossible for these DNA assemblers to handle the huge amount of data produced by the next-generation sequencing technologies where the number

*n*of strings could be several billions. If the overlap graph is explicitly stored, it would require (

*n*

^{2}) memory, which could be prohibitive in practice when

*n*is greater than a hundred million. In this article, we propose a novel data structure using which the overlap graph can be compactly stored. This data structure requires only linear time to construct and and linear memory to store.

**Results:**For a given set of input strings (also called

*reads*), we can informally define an exact-match overlap graph as follows. Each read is represented as a node in the graph and there is an edge between two nodes if the corresponding reads overlap sufficiently. A formal description follows. The maximal exact-match overlap of two strings

*x*and

*y*, denoted by

*ov*

_{max}(

*x*,

*y*), is the longest string which is a suffix of

*x*and a prefix of

*y*. The exact-match overlap graph of

*n*given strings of length is an edge-weighted graph in which each vertex is associated with a string and there is an edge (

*x*,

*y*) of weight =–|

*ov*

_{max}(

*x*,

*y*)| if and only if ≤, where |

*ov*

_{max}(

*x*,

*y*)| is the length of

*ov*

_{max}(

*x*,

*y*) and is a given threshold. In this article, we show that the exact-match overlap graphs can be represented by a compact data structure that can be stored using at most (2–1)(2log

*n*+log)

*n*bits with a guarantee that the basic operation of accessing an edge takes

*O*(log ) time. We also propose two algorithms for constructing the data structure for the exact-match overlap graph. The first algorithm runs in

*O*(

*n*log

*n*) worse-case time and requires

*O*() extra memory. The second one runs in

*O*(

*n*) time and requires

*O*(

*n*) extra memory. Our experimental results on a huge amount of simulated data from sequence assembly show that the data structure can be constructed efficiently in time and memory.

**Availability:**Our DNA sequence assembler that incorporates the data structure is freely available on the web at http://www.engr.uconn.edu/~htd06001/assembler/leap.zip

## No comments:

## Post a Comment