WO2016112618A1

WO2016112618A1 - Distance-based algorithm for solving representative node set in two dimensional space

Info

Publication number: WO2016112618A1
Application number: PCT/CN2015/081146
Authority: WO
Inventors: 李荣华; 蔡涛涛; 毛睿; 邱宇轩; 秦璐
Original assignee: 深圳大学
Priority date: 2015-01-16
Filing date: 2015-06-10
Publication date: 2016-07-21
Also published as: CN104573036B; CN104573036A

Abstract

A new distance-based algorithm for solving the representative Skyline node set in two dimensional space is provided, inputting a data set, calculating a Skyline node set Q in the data set using BNL algorithm; after sorting the node set Q, solving the Manhattan distance value from an initial node to any other Skyline node and storing same; solving a number k of representative Skyline nodes in the Skyline node set; returning a number k of representative Skyline nodes. The time complexity of the algorithm is O (k2log3m), which is far less than the time complexity of the DRS algorithm in the prior art.

Description

An Algorithm for Solving Representative Node Sets in Two-Dimensional Space Based on Distance

Technical field

The invention relates to a new distance-based algorithm for solving a representative node set in a two-dimensional space (New Distance-based Representative Skyline, NDRS for short).

Background technique

The Skyline query question was proposed by Borzsonyi in 2001. In recent years, Skyline's query processing has attracted the attention of a large number of database researchers, and has quickly become a research hotspot in the database field. A large number of Skyline query processing algorithms have emerged. The existing results mainly cover three aspects:

(1) Skyline query processing on centralized database: including BNL algorithm (Block Nested Loop), SFS algorithm (Sort Filter Skyline), Divide and Conquer algorithm, Bitmap algorithm, Index algorithm (Index) [5], NN algorithm (Nearest Neighbor), BBS (Branch and Bound Skyline) [3] and so on.

(2) Skyline query processing on distributed database: including Skyline calculation in common distributed environment, Skyline calculation in special distributed environment, Skyline calculation on peer-to-peer network, etc.

(3) Skyline query processing under other calculation models: including Skyline result set size and calculation cost estimation, Skyline query processing on any subspace, Skyline query processing on all subspaces, and Skyline query processing on the data stream. Wait.

Although the Skyline algorithm under the traditional definition is relatively mature, there are still many aspects that still need improvement. The most striking thing is that the number of Skyline points returned via Skyline query in many application scenarios is too large to serve multi-target decisions.

In order to solve this problem, Lin Xuemin and others first proposed the concept of “Top-k representative Skyline (TRS)” in 2007, that is, select k Skyline points from Skyline points as “representative Skyline points”. And the selected k nodes need to satisfy the following conditions: the number of points in the data set dominated by the selected k Skyline points is greater than or equal to the arbitrarily selected k Skyline points from the Skyline point set. (dominate) the number of points in the data set. The meaning of the dominant is as follows: the points x=(x1,x2,...,xd) and y=(y1,y2,...,yd) given two d-dimensional coordinates, if for any integer i∈[ 1, d], all have xi ≤ yi, and there is an i such that xi < yi, then point x dominates point y. Similarly, Tao Yufei et al. proposed the “Distance-based Representative Skyline” strategy in 2009, which is defined as: the selected k points are satisfied.

Er(κ,S) represents the maximum distance value that can be obtained from all non-representative skyline points in the Skyline point to the nearest representative skyline point, and then solved by the dynamic programming algorithm to obtain the final representative Skyline point set, called DRS algorithm. Where κ represents the set of points of “Representative Skyline” and S refers to the set of all nodes in the data set. This patent will primarily use the definition of representative Skyline based on distance.

Among the above algorithms, the TRS algorithm has an obvious disadvantage, that is, the selected "representative Skyline point" has a certain degree of bias, and tends to be relatively dense in the data concentration point, and its time complexity (O(km ² +nlog(m))) is too high, where n represents the number of points in the data set and m represents the number of Skyline points. Therefore, the effectiveness of TRS will be difficult to guarantee in the context of large data scales and concentrated data distribution. Although the DRS algorithm solves the defect that TRS does not represent the entire Skyline point set well, the time complexity is still too high (O(|D|.log(m)+m ² (k-2))) , where |D| represents the size of the data set, which severely limits the scope of the algorithm.

Summary of the invention

The invention provides a new distance-based algorithm for solving representative Skyline node sets in two-dimensional space, and the time complexity of the algorithm is O(k ² log ³ m), which is much lower than the time complexity of the DRS algorithm.

The invention is achieved by the following technical means:

An algorithm for solving a representative set of nodes in a two-dimensional space based on distance, comprising the following steps:

S1, input data set, calculate the Skyline point set Q in the data set by using the BNL algorithm; sort the point set Q to find the Manhattan distance value from the initial point to any other Skyline point and store it;

S2, find k representative Skyline points in the Skyline point set; first introduce the Testing (B) algorithm to determine whether there are k areas with a radius not greater than B that can cover the entire Skyline point set, and if so, return Correct, otherwise return an error; then set

A total of k subscripts, where S ₀ =1 is 1 ≤ i ≤ k-1; Testing(radius(S _i-1 , S _i )) is satisfied and Testing(radius(S _i-1 , S _i +1) )) is correct, then

Let B _opt =Er(κ,S), where κ represents the set of "representative Skyline points", which is the input value, S represents the set of all nodes in the data set, and ||p,p'|| represents the points p and p' Euclidean distance

S3, Bring B _opt into Testing (B _opt ), and returning k representative Skyline points.

Wherein, in the data set, the center point center(i, j) of the plurality of Skyline points {p _i , . . . p _j } covered by the region [i, j] and the circle of the circle centered on the center point are obtained. The minimum radius radius(i,j), 1≤i≤j≤m, where m is the number of elements of the Skyline point set; defining centre(i,j)=p _u , satisfied

In the two-dimensional space, the representative Skyline solved by the NDRS algorithm can accurately represent the overall situation of the Skyline point set, by feeding back k "representative Skyline" points to the decision maker, and then selecting the representative Skyline for the decision maker. The point "expansion interval" is developed, and the second decision is made to the Skyline point in the interval, which perfectly solves the problem that the Skyline point set is too large to be detrimental to the decision maker's decision making, and makes the Skyline technology better serve the multi-objective decision. In the case where the Skyline point set is known, the time complexity of the algorithm of the present invention is O(k ² log ³ m) compared to the DRS algorithm, which is much lower than the time complexity of the DRS algorithm.

DRAWINGS

1 is a schematic diagram of an algorithm process of the present invention;

Figure 2 is a schematic diagram of a point set;

Figure 3 Schematic diagram of multiple Skyline points covered by a region [i, j]

Figure 4 shows the coverage ring of interval [3,6] and interval [5,6]

Figure 5 shows the change of the radius(i,j) of the interval [1,5] with the value of center(i,j).

Detailed ways

The implementation process of the present invention will be described in detail below with reference to the accompanying drawings.

A distance-based algorithm for solving representative node sets in two-dimensional space, using a binary parameter search technique, introducing a Testing function to test the feasibility of distance, and redesigning a new algorithm for calculating radius, making the program The execution time is greatly reduced. As shown in Figure 1, the specific process is as follows:

First, pretreatment

(1) Calculate the corresponding Skyline point set in the data set

In the given data set, the BNL algorithm is used to find the Skyline point set that can cover the entire data set.

The general framework of the algorithm is as follows

Input: data set G=(x,y)

Output: Skyline Point Set

1.1 Sort all points in the data set according to the value of x from large to small;

1.2 Add the first node of the sorted data set to the Skyline point set;

2 Contrast the y value of the current point with the Skyline point with the largest y value in the Skyline point set. If it is greater than the largest Skyline point, add the current point to the Skyline point set, otherwise it will not be added. Loop through this operation until all points have been searched.

3 Sort and output the Skyline point set.

This preprocessing algorithm can be done within the time complexity of O(nlogn).

(2) Find the center point center(i,j) of the plurality of Skyline points {p _i ,....p _j } covered by one region [i,j] and the minimum radius of the circle covering the center point as the center Radius(i,j), where m is the number of elements of the Skyline point set, 1 ≤ i ≤ j ≤ m. Define central(i,j)=p _u to satisfy

The general framework of the algorithm is as follows:

Input: subscript i, j;

Output: center(i,j), radius(i,j);

1.1 if i = j, center (i, j) = i, radius (i, j) = 0;

1.2 Otherwise, let left=i,right=j; when left<right.

1.2.1 Order

Mid1=(left+right)/2,FR=||p _j ,p _mid1 ||,FL=||p _mid1 ,p _i ||;

1.2.2 if FR < FL, right = mid1;

1.2.3 otherwise

1.2.3.1 If FR>FL, left+=mid1

1.2.3.2 Otherwise center(i,j)=mid1,radiis(i,j)=||p _j ,p _mid1 ||;

1.3Mid1=right;

1.4 if

1.4.1mid1=mid1-1;

1.4.2 otherwise mid1 is unchanged

1.5 returns center(i,j)=mid1,radiis(i,j)=||p _j ,p _mid1 ||;

Find the center point of multiple Skyline points {p _i ,....p _j } covered by the region [i,j]

Radius(i,j) can be done within the time complexity of O(log(m)).

Second, the k representative Skyline points are solved by the known Skyline point set.

(1) Introduce the Testing (B) algorithm to determine whether there are k areas that can be covered by a ring of radius (i, j) when 1 ≤ i ≤ j ≤ m and radius(i, j) <= B Can contain the entire Skyline point set, and if so, return correctly, otherwise an error is returned.

The general framework of the algorithm is as follows:

Input: B, the sorted Skyline point set (containing m elements), and the subscript S _i where 1 ≤ _i ≤ m.

Output: correct or wrong

1.1

Where 1 ≤ i ≤ m initialization p = 0;

1.2 when p<k-1

1.2.1 Bivariate search BiNSRCH(S _i +1,j,S _i+1 ) up to max(radius(S _i +1,S _i+1 ))<=B. At the same time, store central(S _i +1,S _i+1 ) as the representative Skyline under B, so that p+=1;

1.3 If radius(S _k-1 +1,S _k )<=B, the return is correct, otherwise an error is returned.

(2) in order to solve the satisfaction

Er(κ, S), set first

A total of k subscripts, where S ₀ =1 makes 1 ≤ i ≤ k-1 satisfying Testing(radius(S _i-1 , S _i )) as an error and Testing(radius(S _i-1 ,S _i +1) ) is correct, then

Then return the corresponding k representative Skyline points.

The algorithm applies the Distance-Testing strategy, which is the RSP algorithm. The general framework of the algorithm is as follows:

Input: sorted Skyline point set (including m elements), center(i,j), radius(i,j) when 1≤i≤j≤m

Output: k representative Skyline points, B _opt .

1.1 Let {S ₀ , S ₁ ,....S _k-1 }, where S ₀ =1

1.2for b<-1 to P-1 execution

1.2.1ilow<-S _b-1 ;ihigh<--m;

1.2.2 when ilow<ihigh is executed

Imid<-(ilow+ihigh)/2;

1.2.3B<-radius(S _i-1 ,S _i +1)

1.2.4 If Testing(B) then

Ihigh<-imid;

1.2.5 otherwise

Ilow<-imid+1;

1.2.6S _k-1 <-ihigh;

1.2.7B _k-1 <-radius(S _k-1 +1,S _k-2 )

B _P <-radius(S _p-1 ,m)

1.3Return

k representative Skyline points;

The NDRS algorithm mainly uses the Distance-Testing technique, which is mainly used to solve the representative Skyline point ("RSP") in the case where the Skyline point set is known, and is called the DisBase algorithm.

The main idea of the DisBase algorithm is to select from the corresponding subscripts of m rows of Skyline points.

S ₀ =0, a total of k subscripts, these subscripts satisfy the following conditions: when 1≤i≤k-1, there is radius(1,S ₁ )<B _opt <raidus(1,S ₁ +1), and Radius(S _i +1,S _i+1 )<B _opt <raidus(S _i +1,S _i+1 +1) and the final

The time complexity of this part is O(klogm.logm), and then the final k representative Skyline points (ie RSP) are returned by Testing(B _opt ). The time complexity of this part is O(k.logm), so The time complexity of the algorithm is O(k ² log ³ m).

The following is the specific idea of the NDRS algorithm and its correctness proof.

Theorem 1: When B ≥ B _opt , Testing (B) is correct.

Proof: Assume that when B ≥ B _opt , Testing (B) is an error, indicating that there is no circle with k radii not greater than B that can completely cover the entire Skyline point set, and B ≥ B _opt , then there is no possibility of any A circle with k radii not greater than B _opt can completely cover the entire Skyline point set, that is, Testing (B _opt ) is an error, which is inconsistent with the fact, thereby confirming that theorem 1 holds.

Theorem 2: Let B _opt be a circle whose k radius is not greater than B _opt can completely cover the minimum value of the Skyline point set, then

Proof: It is known from the definition of {S ₀ , S ₁ , ....S _k-1 } that for any 1≤i≤k-1, Testing(radius(S _i-1 +1,S _i +1) is satisfied. )) is correct. Then we only need to prove that B _opt exists in

In the middle, it is only necessary to prove that the index of the first Skyline point covered by the first circle C ₁ is ₁ , and the first Skyline point covered by the i-th circle C _i except 1 Marked as S _i-1 +1. Since radius(1,S ₁ )<B _opt , it is impossible for {2,...S ₁ } to be the subscript of the first Skyline point covered by the circle corresponding to B _opt , and the same is true for any { S _i +2, S _i+1 } cannot be the subscript of the first Skyline point covered by the circle corresponding to B _opt , and thus theorem 2 is proved.

In the prior art, the technique for solving Skyline has been relatively perfect. Based on the pre-processed Skyline point set, the present invention further searches for k representative Skyline points by the NDRS algorithm, which greatly reduces the decision-making range of the decision maker.

Now take the point set in Figure 2 as an example to further illustrate the implementation process of the algorithm.

Purpose: Find k = 3 representative Skyline points.

First, pretreatment

1.1 Calculate the corresponding Skyline point set in the data set

In the given data set {p ₁ , p ₂ ,..., p ₁₂ }, the BNL algorithm is used to find the Skyline point set {p ₁ , p ₂ ..., p ₆ } that can cover the entire data set. .

1.2 Find the center point center(i,j) and radius(i,j) of multiple Skyline points {p _i ,....p _j } covered by a region [i,j] as shown in Fig. 3 The following method, here is the online algorithm, non-offline algorithm.

Radius(i,j) can be done within the time complexity of O(log(m)).

Figure 4. Covering rings for interval [3,6] and interval [5,6]. Figure 5 shows the value of radius(i,j) for interval [1,5] with center(i,j). Change situation. It is easy to know that radius(1,5)=10, center(1,5)=3 can be quickly found by dichotomy by comparing the sizes of FR and FL.

Second, three representative Skyline points are solved by the known Skyline point set {p ₁ , p ₂ ..., p ₆ }.

As shown in Fig. 5, the Skyline point set {p ₁ , p ₂ ..., p ₆ } has been obtained through the preprocessing stage and can be found between any two Skyline points in the time of O(1). distance. (here ||p ₁ ,p ₂ ||=2,||p ₂ ,p ₃ ||=4,||p ₃ ,p ₄ ||=6,||p ₄ ,p ₅ ||=4, ||p ₅ , p ₆ ||=2), with subscript {S ₀ ,...S _i }, 0<i<k, where S ₀ =1, where k=3. value S _1, S ₂ a, S _1, S ₂ satisfy _{Testing (radius (S i-1} , S i)) and the error _{Testing (radius (S i-1} , S i +1)) is correct.

The specific solution steps are as follows:

1) Find S ₁ , S ₂ by dichotomy, set ilow=1, ihigh=6; imid=(ilow+ihigh)/2=3;

2) Determine Testing(radius(1,3)), call the method in 1.2 to find radi(u1s,3),=4 to make B=4, and Testing(B) can be solved by dichotomy:

2.1) Refer to the testing algorithm pseudo code, the steps are as follows:

1. Set ilow2=1, ihigh2=6; imid2=(ilow2+ihigh2)/2=3;

2.radius(1,3)=B, then ilow2=4, ihigh2=6; imid2=5;

3.radius(4,5)>B, ilow2=4, ihigh2=imid2-1=4;

4.radius(5,6)=2<B, returning correctly.

3) ilow=1, ihigh=imid=4;

3.1) imid=(ilow+ihigh)/2=2;

Testing (imid) = Testing (2), the same as 2.1) method can get Testing (2) as an error, thus obtaining S ₁ = 2.

1) ilow=3, ihigh=6, and similarly, S ₂ =3.

2)

From Testing (B _opt ), the corresponding center(i, j) can be returned as a representative skyline point, and the representative Skyline points are obtained as {p ₂ , p ₄ , p ₅ }.

Claims

An algorithm for solving a representative set of nodes in a two-dimensional space based on distance, comprising the following steps:

S1, input data set, calculate the Skyline point set Q in the data set by using the BNL algorithm; sort the point set Q to find the Manhattan distance value from the initial point to any other Skyline point and store it;

S2, find k representative Skyline points in the Skyline point set; first introduce the Testing (B) algorithm to determine whether there are k when 1 ≤ i ≤ j ≤ m, radius (i, j) <= B when the radius is radius The area covered by the ring of (i, j) can contain the entire Skyline point set, and if so, the return is correct, otherwise an error is returned; then {S 0 , S 1 , ....S k-1 }, A total of k subscripts, where S 0 =1 is 1 ≤ i ≤ k-1; Testing (radius (S i-1 , S i )) is considered as an error and Testing (radius (S i-1 , S i +1) )) is correct, then
Let B opt =Er(κ,S), where κ represents the set of "representative Skyline points", which is the input value, S represents the set of all nodes in the data set, and ||p,p'|| represents the points p and p' Euclidean distance

S3, Bring B opt into Testing (B opt ), and returning k representative Skyline points.
Based on the distance of the two-dimensional space algorithm representative set of nodes, wherein: in said data region required concentration [i, j] of a plurality of points covering the Skyline {p i, .... p j Center point (i, j) of the } and the minimum radius radius(i, j) of the circle covering the center point, 1 ≤ i ≤ j ≤ m, where m is the number of elements of the Skyline point set; define the centre ( i,j)=p u , satisfied