Spatial Cluster Analysis by the Bin-Packing Problem and DNA Computing Technique

Abstract

Spatial cluster analysis is an important data mining task. Typical techniques include CLARANS, density- and gravity-based clustering, and other algorithms based on traditional von Neumann's computing architecture. The purpose of this paper is to propose a technique for spatial cluster analysis based on sticker systems of DNA computing. We will adopt the Bin-Packing Problem idea and then design algorithms of sticker programming. The proposed technique has a better time complexity. In the case when only the intracluster dissimilarity is taken into account, this time complexity is polynomial in the amount of data points, which reduces the NP-completeness nature of spatial cluster analysis. The new technique provides an alternative method for traditional cluster analysis.

1. Introduction

Spatial cluster analysis is a traditional problem in knowledge discovery from databases [1]. It has wide applications since increasingly large amounts of data obtained from satellite images, X-ray crystallography, or other automatic equipment are stored in spatial databases. The most classical spatial clustering technique is due to Ng and Han [2] who developed a variant PAM algorithm called CLARANS, while new techniques are proposed continuously in the literature aiming to reduce the time complexity or to fit for more complicated cluster shapes.

For example, Bouguila [3] proposed some model-based methods for unsupervised discrete feature selection. Wang et al. [4] developed techniques to detect clusters with irregular boundaries by a minimum spanning tree-based clustering algorithms. By using an efficient implementation of the cut and the cycle property of the minimum spanning trees, they obtain a performance better than 𝑂(𝑁²), where 𝑁 is the number of data points. In another paper, Wang and Huang [5] developed a new density-based clustering framework by a level set approach. By a valley seeking method, data points are grouped into corresponding clusters.

Adleman [6] and Lipton [7] pioneer a new era of DNA computing in 1994 with their experiments which demonstrated that the tools of laboratory molecular biology could be used to solve computation problems. Based on Adleman and Lipton's research, a number of applications of DNA computing in solving combinatorially complex problems such as factorization, graph theory, control, and nanostructures have emerged. There appeared also theoretical studies including DNA computers which are programmable, autonomous computing machines with hardware in biological molecules mode; see [8] for details.

According to Păun et al. [8], common DNA systems in DNA computing include the sticker system, the insertion-deletion system, the splicing system, and H systems. Among those, the sticker system has the ability to represent bits which is similar to the silicon computer memory. In a recent work, Alonso Sanches and Soma [9] propose an algorithm based on the sticker model of DNA computing [10] to solve the Bin-Packing Problem (BPP), which belongs to the class NP-Hard in the strong sense. The authors show that their proposed algorithms have time complexities bounded by 𝑂(𝑛²) which are the first attempt to use DNA computing for the Bin-Packing Problem. Here the integer 𝑛 is the number of items to be put in the bins.

Inspired by the work of Alonso Sanches and Soma [9], we propose a new DNA computing approach for spatial cluster analysis in this paper by the Bin-Packing Problem technique. The basic idea is to take clusters as bins and locate data points into bins. In order to complete evaluation of clustering, we need to accumulate dissimilarities within clusters. By the sticker system we can accomplish these tasks. We also show that our algorithm has a time complexity in polynomial in the case when only intracluster dissimilarity is considered, relative to the amount of data points. Notice that cluster analysis is NP-complete. It is interesting to notice that the method in this paper is new in cluster analysis.

The rest of this paper is organized as follows: in Section 2, we present the Bin-Packing Problem formulation of spatial clustering problem for the purpose of this paper. Then in Section 3 some basic facts on sticker model are presented with implementation of some new operations. The following two sections are devoted to the coding of the problem and the algorithms of clustering with sticker system. Finally, a brief conclusion is reached.

2. Formulation of the Problem

Let 𝑅^𝑛 be the real Euclidean space of dimension 𝑛. A subset Ω⊂𝑅^𝑛 is called a spatial dataset with 𝑁 points and Ω={𝑥₁,𝑥₂,…,𝑥_𝑁}, where 𝑥_𝑖=(𝜉_𝑖1,𝜉_𝑖2,…,𝜉_𝑖𝑛)∈𝑅^𝑛 for each 𝑖=1,…,𝑁. A clustering problem over Ω is to group the dataset Ω into 𝑘 partitions called clusters where the intracluster similarity is maximal and the intercluster similarity is minimal. In this sense, clustering is an optimization process in two levels: one is maximization and the other is minimization. Here the integer 𝑘 indicates the number of clusters. There are two kinds of clustering when we consider 𝑘 as a parameter. The first kind is fixed number clustering, where the number of clusters 𝑘 is a priori determined. The second kind is flexible clustering where the number 𝑘 is chosen as one of the parameters to meet the two level optimization problem.

Now we denote a partition of Ω by 𝒞∶𝒞=(𝐶₁,…,𝐶_𝑘) with Ω=𝐶₁∪⋯∪𝐶_𝑘 and 𝐶_𝑖⊆Ω for 1≤𝑖≤𝑘. If we define Asim(𝐶_𝑖) as the intracluster dissimilarity measure for 𝐶_𝑖∈𝒞 and Simm(𝐶_𝑖,𝐶_𝑗) as the intercluster similarity measure for 𝐶_𝑖,𝐶_𝑗∈𝒞, then the two kinds of clustering problems are formulated as follows: min_𝒞Asim𝐶_𝑖for1≤𝑖≤𝑘,min_𝒞Simm𝐶_𝑖,𝐶_𝑗for1≤𝑖,𝑗≤𝑘,𝑖≠𝑗,min_𝒞,𝑘Asim𝐶_𝑖for1≤𝑖≤𝑘,min_𝒞,𝑘Simm𝐶_𝑖,𝐶_𝑗for1≤𝑖,𝑗≤𝑘,𝑖≠𝑗. (1)(2)

To simplify the multiplicity of optimization, we often use the following variation of the above problems: min_𝒞^𝑘_𝑖=1Asim𝐶_𝑖,min_{𝒞1≤𝑖,𝑗≤𝑘,𝑖≠𝑗}Simm𝐶_𝑖,𝐶_𝑗,min^𝑘_{𝒞,𝑘𝑖=1}Asim𝐶_𝑖,min_{𝒞,𝑘1≤𝑖,𝑗≤𝑘,𝑖≠𝑗}Simm𝐶_𝑖,𝐶_𝑗. (3)(4)

Next we only consider the cluster problem (1) or (3). In order to unite the two optimization formula: we introduce the following total energy function: min_𝒞𝐸_𝑇(𝒞)∶𝐸_𝑇(𝒞)=^𝑘_𝑖=1Asim𝐶_𝑖+_{1≤𝑖,𝑗≤𝑘,𝑖≠𝑗}Simm𝐶_𝑖,𝐶_𝑗. (5)

For the purpose of this paper, we will use a simplified version of the total energy as shown in the following equation:min_𝒞𝐸(𝒞)∶𝐸(𝒞)=^𝑘_𝑖=1Asim𝐶_𝑖. (6)

In the case when the number of clusters 𝑘 is a variable, the total energy is computed for nonempty clusters and the optimized number 𝑘 of clusters is the counting of nonempty bins: min_𝒞𝐸(𝒞)∶𝐸(𝒞)=_{1≤𝑖≤𝑘,𝐶𝑖≠∅}Asim𝐶_𝑖. (7)

We now propose a Bin-Packing Problem (BPP) formulation of the clustering problem as stated above. The classical one-dimensional BPP is given as a set of 𝑁 items 𝑥₁,…,𝑥_𝑁 with respective weights 𝑤(𝑥_𝑖)=𝑎_𝑖∈(0,𝑐],1≤𝑖≤𝑁. The aim is to allocate all items into 𝑁 bins with equal capacity 𝑐 and by using a minimum number of bins [9]. For clustering purpose we assume that there are 𝑘 empty bins and we allocate all items into the bins with least energy. If we consider 𝑘 as a variable, then the problem is to allocate 𝑁 points into 𝑁 bins with least energy. The capacity restriction 𝑐 is removed. For the two cases of clustering, there are altogether 𝑘^𝑁 (𝑁^𝑁, resp.) combinations of allocation and the best solution can be achieved by brute force search.

First we consider the case when 𝑘 is fixed. To solve the problem, we consider an array 𝒞 of integers 𝒞=𝑐₁𝑐₂⋯𝑐_𝑁,each𝑐_𝑖∈{1,…,𝑘}. (8)

The 𝑖th bin (cluster) 𝐶_𝑖 is defined as 𝐶_𝑖={𝑥_𝑝∶𝑐_𝑝=𝑖,𝑝=1,…,𝑁} for 𝑖=1,…,𝑘. We will identify the allocation 𝒞 with its corresponding partition. Therefore the energy function is defined on {𝒞} of all allocations. In order to guarantee the bins are nonempty, we need to add a restriction that #(𝐶_𝑖)>0 for 𝑖=1,…,𝑘, where #(𝐶_𝑖) denote the cardinality of the set 𝐶_𝑖.

Then the final problem is min𝐸(𝒞),𝒞=𝑐₁𝑐₂⋯𝑐_𝑁,each𝑐_𝑖∈{},#𝐶1,…,𝑘_𝑖>0for𝑖=1,…,𝑘. (9)

Next when 𝑘 is a variable, the array 𝒞 is 𝒞=𝑐₁𝑐₂⋯𝑐_𝑁,each𝑐_𝑖∈{1,…,𝑁}. (10)

The 𝑖th bin (cluster) 𝐶_𝑖 is defined as 𝐶_𝑖={𝑥_𝑝∶𝑐_𝑝=𝑖,𝑝=1,…,𝑁} for 𝑖=1,…,𝑁. The energy function defined on {𝒞} to be optimized is min𝐸(𝒞),𝒞=𝑐₁𝑐₂⋯𝑐_𝑁,each𝑐_𝑖∈{1,…,𝑁}. (11)

3. A Sticker DNA Model

First we recall some standard operations of DNA computing as shown in [8]. They are merge, amplify, detect, separate, and append.(i)merge: 𝑇←𝑚𝑒𝑟𝑔𝑒(𝑇₁,𝑇₂). Two given tubes 𝑇₁and𝑇₂ are combined into one 𝑇 without changing the strands which.(ii)amplify: Given a tube 𝑇, amplify (𝑇,𝑇₁,𝑇₂) produces two copies 𝑇₁,𝑇₂ of 𝑇 and then make 𝑇 empty.(iii)detect: Given a tube 𝑇, return true if 𝑇 contains at least one DNA strand, otherwise return false.(iv)separate: 𝑇←+(𝑇,𝑤) and 𝑇←−(𝑇,𝑤). Given a tube 𝑇 and a word 𝑤, a new tube +(𝑇,𝑤) (or −(𝑇,𝑤)) is produced with the strands in 𝑇 which contain 𝑤 as 𝑠 substring (resp., do not contain).(v)append: Given a tube 𝑇 and a word 𝑤, 𝑎𝑝𝑝𝑒𝑛𝑑(𝑇,𝑤) affixes 𝑤 at the end of each sequence in 𝑇.

The sticker model is based on the paradigm of Watson-Crick complementarity and was first proposed in [10]. There are two kinds of single-stranded DNA molecules, the memory strands and sticker strands, in this model. A memory strand is 𝐿 bases in length and contains 𝑝 nonoverlapping substrands, each of which is 𝑚 bases long, where 𝐿=𝑝𝑚 [8]. A sticker is 𝑚 bases long and complementary to exactly one of the 𝑝 substrands in the memory strand. A specific substrand of a memory strand is either on or off and is called a bit. If a sticker is annealed to its matching substrand on a memory strand, then the particular substrand is said to be on. Otherwise it is said to be off. These partially double strands are called memory complexes.

The basic operations of the sticker model are merge, separate, set, and clear and are listed as follows [8]. Among these, merge is exactly as the standard operation as shown before.(i)separate: 𝑇←+(𝑇₀,𝑖) and 𝑇←−(𝑇₀,𝑖). Given a tube 𝑇₀, a new tube +(𝑇₀,𝑖) (or −(𝑇₀,𝑖)) is produced with the 𝑖th bit on (resp., off).(ii)set: 𝑇←𝑠𝑒𝑡(𝑇₀,𝑖). A new tube 𝑇 is produced from 𝑇₀ by turning the 𝑖th bit on.(iii)clear: 𝑇←𝑐𝑙𝑒𝑎𝑟(𝑇₀,𝑖). A new tube 𝑇 is produced from 𝑇₀ by turning the 𝑖th bit off.

Now we consider a test tube 𝑇 consisting memory complexes 𝛼. We define the length of 𝛼 as the number of bits, that is, the number of substrands (stickers) contained in 𝛼 denoted by 𝑝(𝛼). Each numerical value is represented by 𝑞-bit stickers, where 𝑞 is a constant designed for a certain problem. For a 𝑞-bit stickers 𝛼, the corresponding numerical value is denoted by ℎ(𝛼). The substring in a memory complex from the (𝑏+1)th bit to the (𝑏+𝑞)th bit of 𝛼 is denoted by 𝑐𝑢𝑡(𝛼,𝑏), where 𝑏 is an integer with 0≤𝑏≤𝑝(𝛼)−1. Apart from the basic operations, we need more operations designed and inspired by Alonso Sanches and Soma [9] in order to handle numerical computations.(i)increment: 𝑇←𝑖𝑛𝑐𝑟(𝑇,𝑏). For each 𝛼∈𝑇, generate a strand 𝛽 with ℎ(𝑐𝑢𝑡(𝛽,𝑏))=ℎ(𝑐𝑢𝑡(𝛼,𝑏))+1 and let 𝑇 be replaced by the collection of such new strands 𝛽.(ii)add: 𝑇←𝑎𝑑𝑑(𝑇,𝑏,𝑑). For each 𝛼∈𝑇, generate a strand 𝛽 with ℎ(𝑐𝑢𝑡(𝛽,𝑏))=ℎ(𝑐𝑢𝑡(𝛼,𝑏))+𝑑 and let 𝑇 be replaced by the collection of such new strands 𝛽. Here 𝑑 is an integer in binary form with length 𝑝(𝛼)−𝑏.(iii)compare: 𝑐𝑜𝑚𝑝𝑎𝑟𝑒(𝑇,𝑏₁,𝑏₂,𝑇_𝑙,𝑇_𝑔,𝑇_𝑒). For each 𝛼∈𝑇, if ℎ(𝑐𝑢𝑡(𝛼,𝑏₁))<ℎ(𝑐𝑢𝑡(𝛼,𝑏₂)), then let 𝛼∈𝑇_𝑙; if ℎ(𝑐𝑢𝑡(𝛼,𝑏₁))>ℎ(𝑐𝑢𝑡(𝛼,𝑏₂)), then let 𝛼∈𝑇_𝑔; else let 𝛼∈𝑇_𝑒.(iv)weigh: 𝑤𝑒𝑖𝑔ℎ(𝑇,𝑏,𝑑,𝑇_𝑙,𝑇_𝑔,𝑇_𝑒). For each 𝛼∈𝑇, if ℎ(𝑐𝑢𝑡(𝛼,𝑏))<𝑑, then let 𝛼∈𝑇_𝑙; if ℎ(𝑐𝑢𝑡(𝛼,𝑏))>𝑑, then let 𝛼∈𝑇_𝑔; else let 𝛼∈𝑇_𝑒.(v)clearq: 𝑐𝑙𝑒𝑎𝑟𝑞(𝑇,𝑏). For each strand in the tube 𝑇, turn all bits off from (𝑏+1)th bit to (𝑏+𝑞)th bit.

We only give a DNA algorithm for 𝑤𝑒𝑖𝑔ℎ and 𝑐𝑙𝑒𝑎𝑟𝑞 as the other algorithms are presented in Alonso Sanches and Soma [9]. Suppose the binary digits of the integer 𝑑 is 𝑑_𝑏+1𝑑_𝑏+2⋯𝑑_𝑏+𝑞 (see Algorithm 1).

weigh (𝑇,𝑏,𝑑,𝑇𝑙,𝑇𝑔,𝑇𝑒)  𝑖←1; 𝑇𝑙←∅; 𝑇𝑔←∅  repeat   𝑇0←−(𝑇,𝑏+𝑖), 𝑇1←+(𝑇,𝑏+𝑖)   if  𝑑𝑖=0 then    𝑇𝑔←𝑇𝑔∪𝑇1; 𝑇←𝑇0   else    𝑇𝑙←𝑇𝑙∪𝑇0; 𝑇←𝑇1   endif   𝑖←𝑖+1  until  (𝑖=𝑞+1)  or (𝑑𝑒𝑡𝑒𝑐𝑡(𝑇)= no)   𝑇𝑒←𝑇 clearq (𝑇,𝑏)  𝑖←1; 𝑇0←∅;  repeat   𝑇0←𝑐𝑙𝑒𝑎𝑟(𝑇,𝑏+𝑖)   𝑇←𝑇0   𝑖←𝑖+1  until  (𝑖=𝑞+1)

Algorithm 1 

Algorithms of weigh and clearq.

4. Sticker Algorithms for Fixed 𝑘

Now we consider solving the spatial clustering problem as described in Section 2, where the number of clusters 𝑘 is fixed, and Ω={𝑥₁,𝑥₂,…,𝑥_𝑁}, 𝑥_𝑖=(𝜉_𝑖1,𝜉_𝑖2,…,𝜉_𝑖𝑛)∈𝑅^𝑛 for each 𝑖=1,2,…,𝑁. A partition of the dataset Ω is denoted by 𝒞 which is an array of integers 𝒞=𝑐₁𝑐₂⋯𝑐_𝑁,∀𝑐_𝑖∈{1,…,𝑘}. (12)

For two points 𝑥,𝑦 we use 𝜌(𝑥,𝑦) to denote the Euclidean distance between them. We use 𝑀=max_{𝑥,𝑦∈Ω}𝜌(𝑥,𝑦) to denote the diameter of Ω. Let the dissimilarity measure of 𝑥,𝑦∈Ω be 𝑑(𝑥,𝑦)=𝜌(𝑥,𝑦)/𝑀∈[0,1]. Now we convert the dissimilarity measure into binary string consisting of “0”s and “1”s. For an acceptable given error rate to measure the dissimilarity 𝜀>0, divide the interval [0,1] into 2^𝐾1 subintervals with equal width 2^−𝐾1<𝜀. Now choose an integer 𝐾 such that 𝑘𝑁²2^𝐾1<2^𝐾. Then we can use a 𝐾 bits string to represent the subintervals. For 𝑧∈[0,1] let its corresponding string be 𝑠(𝑧)=[2^−𝐾1𝑧], where operator [⋅] is the largest integer without exceeding it. We will use a sticker system with 𝑞 stickers in length that is capable of representing numbers between 0,1,…,𝑁and0,1,…,2^𝐾.

Now we define the dissimilarity matrix as 𝐷=𝑑_{𝑖𝑗𝑁×𝑁},𝑑_𝑖𝑗=𝑠𝑑𝑥_𝑖,𝑥_𝑗,𝑖,𝑗=1,…,𝑁. (13)

For the partition 𝒞, the 𝑖th bin (cluster) 𝐶_𝑖 is defined as 𝐶_𝑖={𝑥_𝑝∶𝑐_𝑝=𝑖,𝑝=1,…,𝑁} for 𝑖=1,…,𝑘. A partition is called feasible if 𝐶_𝑖≠∅ for 𝑖=1,2,…,𝑘. The energy of a partition defined by (9) has the following form: 𝐸_𝑡≜Asim𝐶_𝑡=_{𝑖,𝑗∈𝐶𝑡}𝑑_𝑖𝑗,𝐸(𝒞)=^𝑘_𝑡=1𝐸_𝑡. (14)

For an integer 𝑗, we use seq(𝑗) to represent the subsequence of 𝑞 stickers corresponding to 𝑗. Conversely, if 𝑠 is a sequence, we use ℎ(𝑥) to denote the numerical value decoded by the 𝑞-bit sticker 𝑥. By the sticker model [9], a memory complex seq(𝒞) is designed as the coding of 𝒞: seq(𝒞)=seq𝑐₁seq𝑐₂⋯seq𝑐_𝑁. (15)

Then we append 𝑘+1 stickers representing 𝐸₁,…,𝐸_𝑘 and 𝐸=𝐸(𝒞). Finally we append 𝑘 stickers to store the cardinality of clusters. The structure of stickers for our problem is shown in Figure 1. The clustering algorithm consists of four steps as shown in Algorithm 2.

(a) generate: Generate multiple copies of all the 𝑘𝑁 combinations as 𝒞. Append 1,2,…,𝑘    as the position numbers of 𝒞. Then append 𝐸1,…,𝐸𝑘 and 𝐸 to store the energies.  (b) energy: Compute the dissimilarities of the 𝑘 clusters and store the energy.  (c) prune: Discard unfeasible partitions, that is, those where there exists empty clusters.  (d) find: Find the best solution. Now we present algorithms to implement the above procedures.  (a) Generation of all the possible 𝑘𝑁 solutions. Append 𝑘 values in order to store the energies. generate (𝑇)  𝑇0←𝑇  for  𝑖←1 to  𝑁  do   for  𝑗←1  to  𝑘/2  do    𝑎𝑚𝑝𝑙𝑖𝑓𝑦(𝑇0,𝑇2𝑗−1,𝑇2𝑗)   endfor   for  𝑗←1  to  𝑘  do    𝑎𝑝𝑝𝑒𝑛𝑑(𝑇𝑗,𝑠𝑒𝑞(𝑗))   endfor   for  𝑗←1  to  𝑘  do    𝑎𝑝𝑝𝑒𝑛𝑑(𝑇𝑗,𝑠𝑒𝑞(0))   endfor   for  𝑗←𝑘  downto  1  do    𝑇𝑗−1←𝑇𝑗−1∪𝑇𝑗   endfor  endfor  𝑇←𝑇0  𝑎𝑝𝑝𝑒𝑛𝑑(𝑇,𝑠𝑒𝑞(0)).  for  𝑗←1  to  𝑘  do   𝑎𝑝𝑝𝑒𝑛𝑑(𝑇,𝑠𝑒𝑞(0))  endfor  𝑎𝑝𝑝𝑒𝑛𝑑(𝑇,𝑠𝑒𝑞(0))  (b) Energy computation. The problem is to compute totals of energy for those  𝑖  where  𝑐𝑖=𝑗. Hence    𝐸𝑗=∑𝑟,𝑠∈𝐶𝑗,𝑟≠𝑠𝑑𝑟𝑠  and  𝐶𝑗={𝑖∣𝑐𝑖=𝑗}. The total energy is stored in  𝐸.  At the same time,    the counting number of each bin is stored in the following  𝑘  stickers. energy (𝑇)  for 𝑗←1   to  𝑘   do   𝑇𝑗←∅  endfor  for  𝑖←1  to  𝑁  do   for  ←1  to  𝑘  do    𝑐𝑜𝑚𝑝𝑎𝑟𝑒(𝑇,𝑞𝑖,𝑞(𝑁+𝑗),𝑇′1,𝑇′2,𝑇′3)    𝑐𝑙𝑒𝑎𝑟𝑞(𝑇′2,𝑞𝑖)    𝑇𝑗←𝑇𝑗∪𝑇′2    if  𝑑𝑒𝑡𝑒𝑐𝑡(𝑇′2)=  yes  then     𝑖𝑛𝑐𝑟(𝑇𝑗,𝑞(𝑁+2𝑘+1+𝑗))    endif   endfor  endfor  for  𝑗←1  to  𝑘  do   for  𝑖1←1  to  𝑁  do    for  𝑖2←1  to  𝑁  do     𝑎𝑑𝑑(𝑇𝑗,𝑞(𝑁+𝑘+𝑗),∼(ℎ(𝑐𝑢𝑡(𝑇𝑗,𝑖1𝑞)∨ℎ(𝑐𝑢𝑡(𝑇𝑗,𝑖2𝑞)))𝑑𝑖1𝑖2)    endfor   endfor   𝑎𝑑𝑑(𝑇𝑗,𝑞(𝑁+𝑘+𝑗),𝑞(𝑁+2𝑘+1))   𝑇←𝑇∪𝑇𝑗  endfor  (c) The third step is to eliminate unfeasible partitions. This is done by checking the last  𝑘  stickers. prune (𝑇)  𝑇′𝑙←∅, 𝑇′𝑒←∅  𝑇′𝑔←∅  for  𝑖←1  to  𝑘  do   𝑐𝑜𝑚𝑝𝑎𝑟𝑒(𝑇,𝑞(𝑁+2𝑘+1)+𝑖,𝑞(𝑁+3𝑘+2),𝑇′𝑙,𝑇′𝑔,𝑇′𝑒)   𝑇←𝑇′𝑔  endfor  (d) The last step is to find the best solution with least energy. If 𝑑𝑒𝑡𝑒𝑐𝑡(𝑇)= yes in the final step,    then we get the optimal solution. find (𝑇)  𝑇0←∅, 𝑇1←∅  for  𝑖←1  to  𝑞  do   𝑇0←−(𝑇,𝑞(𝑁+2𝑘+1)+𝑖),  𝑇1←+(𝑇,𝑞(𝑁+2𝑘+1)+𝑖)   if  𝑑𝑒𝑡𝑒𝑐𝑡(𝑇0)=  no then    𝑇←𝑇1   else    𝑇←𝑇0   endif  endfor  𝑑𝑒𝑡𝑒𝑐𝑡(𝑇).

Algorithm 2 

Figure 1 

Coding structure of clusters.

5. Sticker Algorithms for Variable 𝑘

In this section we consider cluster analysis when 𝑘 is a variable. In this case a partition of the dataset Ω is denoted by 𝒞 which is an array of integers 𝒞=𝑐₁𝑐₂⋯𝑐_𝑁,∀𝑐_𝑖∈{1,…,𝑁}. (16)

Similar to the previous section, the 𝑖th bin (cluster) 𝐶_𝑖 is defined as 𝐶_𝑖={𝑥_𝑝∶𝑐_𝑝=𝑖,𝑝=1,…,𝑁} for 𝑖=1,…,𝑁. Notice that 𝐶_𝑖 may be empty and the final number of clusters is the counting of nonempty clusters. The energy of a partition defined by (11) has the following form: 𝐸(𝒞)=^𝑘_𝑡=1𝐸_𝑡,𝐸_𝑡=_𝑖,𝑗∑_∈𝐶𝑡𝑑_𝑖𝑗for𝐶_𝑡≠∅,0for𝐶_𝑡=∅. (17)

Now the coding is seq(𝒞). Then we append 𝑁+1 numbers of 𝑞 bits, that is, (𝑁+1)𝑞 stickers representing 𝐸₁,…,𝐸_𝑁 and 𝐸=𝐸(𝒞). Next we append 𝑁 values to store the counting number of the 𝑁 clusters. Finally we append a value to store the number of valid (nonempty) clusters. The structure of stickers in this case is shown in Figure 2.

Figure 2 

Coding structure when 𝑘 is changing.

The clustering algorithm consists of four steps as shown in Algorithm 3.

(a) generate: Generate multiple copies of all the  𝑁𝑁  combinations as  𝒞.  Append 1,2,…,𝑁    as the position numbers of 𝒞. Then append 𝐸1,…,𝐸𝑁 and 𝐸 to store the energies.  (b) energy: Compute the dissimilarities of the 𝑁 possible clusters and store in energy.  (c) find: Find the best solution.  (d) count: Count the number of clusters. Now we present algorithms to implement the above procedures.  (a) Generation of all the possible  𝑁𝑁 solutions. Append 𝑁 values in order to store the energies. generate (𝑇)  𝑇0←𝑇  for  𝑖←1  to  𝑁  do   for  𝑗←1  to  𝑁/2    𝑎𝑚𝑝𝑙𝑖𝑓𝑦(𝑇0,𝑇2𝑗−1,𝑇2𝑗)   endfor   for  𝑗←1  to  𝑁    𝑎𝑝𝑝𝑒𝑛𝑑(𝑇𝑗,𝑠𝑒𝑞(𝑗))   endfor   for  𝑗←1  to  𝑁    𝑎𝑝𝑝𝑒𝑛𝑑(𝑇𝑗,𝑠𝑒𝑞(0))   endfor   for  𝑗←𝑁  downto  1    𝑇𝑗−1←𝑇𝑗−1∪𝑇𝑗   endfor  endfor  𝑇←𝑇0  𝑎𝑝𝑝𝑒𝑛𝑑(𝑇,𝑠𝑒𝑞(0)).  for  𝑗←1  to  𝑁   𝑎𝑝𝑝𝑒𝑛𝑑(𝑇𝑗,𝑠𝑒𝑞(0))  endfor  𝑎𝑝𝑝𝑒𝑛𝑑(𝑇,𝑠𝑒𝑞(𝑁)).  (b) Energy computation. The problem is to compute totals of energy for those  𝑖  where 𝑐𝑖=𝑗.   Hence 𝐸𝑗=∑𝑟,𝑠∈𝐶𝑗,𝑟≠𝑠𝑑𝑟𝑠  and  𝐶𝑗={𝑖∣𝑐𝑖=𝑗}.  The total energy is stored in  𝐸.  At the same time,    the counting number of each bin is stored in the following  𝑁  stickers. energy (𝑇)  for  𝑗←1  to  𝑁  do   𝑇𝑗←∅  endfor  for  𝑖←1  to  𝑁  do   for  𝑗←1  to  𝑁  do    𝑐𝑜𝑚𝑝𝑎𝑟𝑒(𝑇,𝑞𝑖,𝑞(𝑁+𝑗),𝑇′1,𝑇′2,𝑇′3)    𝑐𝑙𝑒𝑎𝑟𝑞(𝑇′2,𝑞𝑖)    𝑇𝑗←𝑇𝑗∪𝑇′2    if  𝑑𝑒𝑡𝑒𝑐𝑡(𝑇′2)= yes then     𝑖𝑛𝑐𝑟(𝑇𝑗,𝑞(3𝑁+1+𝑗))    endif   endfor  endfor  for  𝑗←1   to  𝑁   do   for  𝑖1←1   to  𝑁   do    for  𝑖2←1   to  𝑁   do     𝑎𝑑𝑑(𝑇𝑗,𝑞(2𝑁+𝑗),∼(ℎ(𝑐𝑢𝑡(𝑇𝑗,𝑖1𝑞)∨ℎ(𝑐𝑢𝑡(𝑇𝑗,𝑖2𝑞)))𝑑𝑖1𝑖2)    endfor   endfor   𝑎𝑑𝑑(𝑇𝑗,𝑞(2𝑁+𝑗),𝑞(3𝑁+1))   𝑇←𝑇∪𝑇𝑗  endfor  (c) The next step is to find the best solution with least energy. If  𝑑𝑒𝑡𝑒𝑐𝑡(𝑇)= yes in the final step,    then we get the optimal solution. The final number  𝑘  of clusters in stored in the last sticker. find (𝑇)  𝑇0←∅, 𝑇1←∅  for  𝑖←1  to  𝑞  do   𝑇0←−(𝑇,𝑞(3𝑁+1)+𝑖),  𝑇1←+(𝑇,𝑞(3𝑁+1)+𝑖)   if  𝑑𝑒𝑡𝑒𝑐𝑡(𝑇0)=  no then    𝑇←𝑇1   else    𝑇←𝑇0   endif  endfor  𝑑𝑒𝑡𝑒𝑐𝑡(𝑇).  (d) The final step is to count the number of clusters. It is stored in the last sticker while in the variable  𝑘. count (𝑇)  𝑘←0  for  𝑖←1  to  𝑁  do   𝑤𝑒𝑖𝑔ℎ(𝑇,𝑞(3𝑁+1+𝑖),0,𝑇𝑙,𝑇𝑔,𝑇𝑒)   if  𝑑𝑒𝑡𝑒𝑐𝑡(𝑇𝑔)= yes then    𝑖𝑛𝑐𝑟(𝑇,𝑞(4𝑁+2))    𝑘←𝑘+1   endif  endfor

Algorithm 3 

6. Conclusion

In this paper we presented a new DNA-based technique for spatial cluster analysis. Two cases when the number of clusters 𝑘 is predefined and not determined are considered. If we take the scale of data 𝑁, and the length of bits for a sticker 𝑞, as a variables, then clearly Algorithm 1 has a time complexity of 𝑂(𝑞𝑁). Among the four steps of Algorithm 2, the operator generate (𝑇) has a time complexity of 𝑂(𝑘𝑞𝑁), and the operator energy (𝑇) has complexity of 𝑂(𝑘𝑞𝑁²). The remaining two operators all have complexity of 𝑂(𝑘𝑞). Thus the total time complexity for fixed number of clusters 𝑘 is 𝑂(𝑘𝑞𝑁²). In the other case when 𝑘 is dynamic, time complexity for the four algorithms changes to 𝑂(𝑞𝑁²), 𝑂(𝑞𝑁³), 𝑂(𝑞), and 𝑂(𝑞𝑁). Hence the total complexity is 𝑂(𝑞𝑁³). The reason why our complexity is worse than that of [9] (of course for a different problem) is that the summation of dissimilarity is time consuming. It is interesting if one can reduce this complexity to 𝑂(𝑞𝑁²).

Finally we will point out that up to the authors knowledge, this is the first research in cluster analysis by sticker DNA systems. It provides an alternative solution for this traditional knowledge engineering problem, which is not combinatorial in nature. Comparing many applications of DNA computing mainly in combinatorial problems, this is still interesting.

Acknowledgments

Research is supported by the Natural Science Foundation of China (no. 61170038, 60873058), the Natural Science Foundation of Shandong Province (no. ZR2011FM001), and the Shandong Soft Science Major Project (no. 2010RKMA2005).