SCP-tree: Finding Multiple Nearest Parking Spots with Minimal Group Travel Cost

Finding the nearest parking location in road networks is one of the most commonly faced challenges in everyday life of green transportation. A main challenge faced by the state-of-the-art existing parking allocation methods is to optimally offer the nearest parking location for a group of m users at the cost of minimal overall traveling time to ensure the traffic and environmental sustainability. In this article, we model it as a Multiple Nearest Parking Location Allocation (MNPLA) problem, and devise a spatial index tree, called SCP-tree, to accelerate the nearest parking location allocation within the users’ time constraints. During the search process in SCP-tree, we build a pruning strategy relevant to the Geographical Preference Estimation, travel time and parking capacity to determine which branch to visit so that the search accuracy can be improved. Considering the users’ behaviors are often impacted by the geographical location and some personalized attribute information, we set the user priority based on them to help the parking officer determine the allocation sequence. We evaluate our allocation scheme using large real-world dataset with on-street parking sensor data, and extensive experimental results reveal (i) a minimum improvement of 15.9%, 1.4%, 96.9%, 160% in parking allocation time, average traveling time, I/O cost and service utility compared to the progressive methods, and (ii) a minimum improvement of 8.9%, 11.1%, 78.2%, 714% in parking allocation time, average traveling time, I/O cost and service utility compared to the baseline methods.


I. INTRODUCTION
In order to reduce energy uses and cut emissions that contribute to the climate and environment change, parking allocation is an important aspect required to be considered in green vehicular transportation, as search for parking by drivers is a significant contributor to the congestion in cities and thus also generates a lot of greenhouse gas emissions [1], [2]. Usually, drivers spend a great deal of time on searching for parking and on leaving sooner or later due to the anticipated parking and congestion problems. Moreover, the unplanned parking allocation can make the travellers, such as coming later, be guided to an unsatisfactory parking location. It is not easy to maximize the benefits of all the mobile users for finding the available parking locations to ensure the sustainability of urban environments [3], which is viewed as a change that improves the quality of life and conserves the time and natural resources.
In essence, vehicle parking can be viewed as a continuous query submitted by mobile users to obtain the available parking locations. Several existing works [4]- [7] compute VOLUME 4, 2016 for parking locations with different costs, and propose some strategies to allocate, such as nash equilibrium, gravity based game-theoretic framework [4]- [6], bipartite matching based natural posted price mechanisms [7], exclusive closest pairs join operation [8] and so on. Each user achieves the preferred parking location by calculating and comparing the prices for available parking locations based on a given selection strategy. However, all these studies have not considered any time and personalized attribute constraint to determine the preference allocation order that (i) helps a centralized parking allocation system to manage the parking locations, and (ii) maximizes the benefits for all users.
In real mobile application scenarios, a mobile user usually wants to know which parking location to visit in order to minimize the time and overall travel distance, specifically the driving distance from the departing location to the parking spot and the walking distance from the parking to the destination. The parking locations are always selected as closer as possible to the destinations since walking may consume much time [9]. However, parking is competitive in nature because after making a choice to visit a particular available parking location, the success in obtaining that parking location will depend on if any other vehicles having a preference for that parking location also make the same choice. Considering this problem, we assume that the centralized parking allocation system has a preference order for each user with different personalized attributes and departing locations, which are deemed as two major factors in modeling users' preferences for selecting parking locations. Meanwhile, the distance from the parking locations to the destinations should be as shorter as possible, which also has an important impact on the traveling time.
Generally, in this article, the objective of the system designer is to set up the user priority in terms of personalized attributes and departing locations, and model the geographical preference to prompt the most effective allocation for available parking locations so that it can serve the maximum number of users within some driving time constraint. At the same time, it should reduce the walking distance from the parking locations to the destination locations as much as possible. Next, we present an example to demonstrate how to allocate the parking locations according to the rules relevant to distance, personalized attributes as well as destinations. A comparison about the allocation result with vehicle-slot (vs) pricing strategy is also given to motivate our work.   Fig. 1 illustrates a motivating example of analysis with 8 departing locations and destination locations (see Fig. 1(a) and (c)) as well as 12 parking locations (see Fig.  1(b)). Each user u i has a profile tuple {l di , age, occupation, driving age}, where l di is the departing location of u i . The attributes afore-mentioned (e.g., age, occupation, driving age) are examples of some personalized attributes of u i . Note that, this list is for illustration, and any other attribute can be similarly accommodated to our approach. The parking officer analyzes the four dominated factors according to the following classification mechanism: (1) In this example, the destinations l s1 , l s2 , l s4 , l s5 , l s6 are nearer to parking locations l pi (i ∈ [1,6]), while the destinations l s3 , l s7 , l s8 are nearer to parking locations l pi (i ∈ [7,12]). The officer allocates the l pi (i ∈ [1,6]) to u 1 , u 2 , u 4 , u 5 , u 6 and l pi (i ∈ [7,12]) to u 3 , u 7 , u 8 , respectively according to the users' departing locations and personalized attributes.
(2) For the user whose age is over 50, and occupation is time limit, as well as driving age is less than 6 years, he/she can be allocated a near parking location, such as u 7 , u 8 .
(3) For the user whose age is below 30, and occupation is time limit, as well as driving age is less than 6 years, he/she can be allocated a near parking location, such as u 5 .
(4) For the user whose age is over 50, and occupation is time free, as well as driving age is more than 10 years, he/she can be allocated a farther parking location, such as u 6 .
(5) For the user whose age is below 30, and occupation is time free, as well as driving age is more than 10 years, he/she can be allocated a farther parking location, such as u 1 .
(6) If more than one user are in the above classifications, they will be competitive in terms of the distance from the departing location to the parking location. The other users, such as u 2 , u 3 , and u 4 , can be allocated mainly considering the departing locations.
Note that the above mentioned strategies are implicit personalization for the parking spot allocation. If there is an explicit preference or constraint for a parking spot, it can be easily accommodated in our approach. If we are to run the above example with vs pricing strategy, assume that it needs a total $-cost of 60 cents on average driving 1 mile. At this case, the pricing authority can assign u 1 a greatly large quantity for l p2 and 0 for l p5 . For u 5 , the pricing authority will assign the prices as 0.5 miles for l p5 and a greatly large quantity for l p2 . The cost that u 5 will have to pay for traveling 0.5 miles converts to 20 cents. Thus, by setting vs prices, the pricing authority stimulates u 1 and u 5 to choose l p2 and l p5 respectively according to the distance minimization assignment. By paying this 20 cents price, u 5 is not necessary to pay the same amount of both $-cost and driving distance. u 1 pays more due to the disadvantages brought, but the pricing authority can compensate her from the money collected from u 5 . The user cannot arbitrarily change her parking location and improve her cost. Thus, it is worthwhile for the drivers to travel a shorter distance in total by the pricing authority. This paper is motivated by the fact that although there is an authority to price on-street parking locations considering both the price and driving distance, the time and personalized attribute constraints still have a large influence on the traveling cost. Thus, we study the question: how to allocate the parking locations to users by considering the dominated constraint factors that have an influence on the overall traveling time? The answer is from the allocation result in Fig.  1(b), where the officer allocates l p5 , l p2 to u 1 , u 5 respectively by considering the users' occupation and driving age. The whole allocation is reasonable since these users belonging to (2) and (3) tend to drive slowly within the limited time, while these users belonging to (4) and (5) tend to drive faster without a time limit. Meanwhile, the traveling time from the parking slot to the users' destinations is within the walking time constraint.
In the following, we list the contributions of this article.
• We propose a new spatial index SCP-tree to represent the parking locations for efficient real-time parking allocation. The branch node regions that are within the walking time constraint to the users' destinations are first positioned. Then, the Lower Bounding Driving Time and parking capacity placed on each index node are used to prune the nodes that cannot satisfy the driving time constraint or have no available parking locations. • We propose User Priority setting based on the personalized attribute and distance, combined with the estimation of geographical location proximity developed for each user, to maximize the benefit of all users. As for a set of users having the similar personalized attributes and closer departing locations, they can be combined into one group for further allocation, especially in peak hours when a large number of users request for parking. • We evaluate our proposed method by the allocation time, traveling time, I/O cost and service utility metrics using a large public dataset provided by the local city council. The experimental results show our proposed method has a significantly efficient allocation performance. The remainder of this article is organized as follows. In Section II, we present a review of related works. In Section III, we present the motivation, and relevant problem definition. In the following, we present the construction process of SCP-tree and parking location allocation scheme in Section IV. Section V contains the evaluation results. Section VI concludes this article.

II. RELATED WORK
Parking Allocation. The notable work, such as optimal system assignments, Nash equilibrium, the price of anarchy, as well as ridesharing relevant to the parking allocation has been studied in the field of transportation applications. U et al. [10] propose a capacity constrained assignment to identify the allocation with the optimal overall quality by employing novel edge-pruning strategies. Ayala et al. [4], [5] analyze the parking situations in competitive simulations through a game-theoretic framework and present the relevant algorithms to choose ideal parking locations. Ayala et al. [6] also propose a vehicle-slot pricing mechanism considering algorithmic game theory, where drivers may pay different prices for the same parking location. Meir et al. [7] study MAXDISTANCE and LINEARCOST valuation schemes for parking allocation through setting up connections with the online bipartite matching problem. In recent years, Tian et al. [11] propose Noah to perform large scale real-time ridesharing. This system accepts requests in real-time and assigns the request to a taxi which is either roaming or having a pre-engaged route. The assignment aims to guarantee the service constraints of the request in terms of waiting time and detour percentage. Cheng et al. [12] propose a utility-aware ridesharing on road networks with the goal of providing optimal rider schedules for vehicles to maximize the overall utility of riders. The focus of it is to assign each rider to a suitable vehicle, subject to the constraint of riders' deadlines of pickup or delivery of riders and the capacity of vehicles. Chen et al. [13] develop a price-and-time-aware ridesharing system by offering more options with different pick-up times and prices. The system assumes that the destination of a vehicle is not limited and that it can accommodate any number of rider groups during a trip as long as it satisfies a capacity constraint. Although these works on ridesharing and our work are both related with the allocation problem, they cannot be directly applied to solve our parking allocation problem. This is because (i) these works on ridesharing may require one vehicle to be allocated to multiple riders for completing its trip. The vehicles' number may be less than the riders' number. However, our work requires only one parking location allocated to one user to complete all the users' trips. The parking locations' number requires to be bigger than or equal to the users' number; (ii) these works on ridesharing aim to maximize the riders' utilities and minimize the vehicles' travel distances, while our work aims to minimize all the users' travel time by allocating the reasonable parking locations to users; (iii) these works on ridesharing suffer the constraints of vehicles' capacities, traveling time and riders' deadlines, while our work suffers the constraint of users' departing-destinations, geographical preference to parking location, personalized attributes that may give different traveling time, as well as parking slot' capacity; (iv) these works on ridesharing consider to satisfy the riders' deadlines in the same trip from one vehicle and the acceptable extra detour time from the shortest possible trip duration, while our work considers to satisfy all the users' traveling time in different trips from the departing locations to the parking locations. In general, all these studies have not considered any time and personalized attribute constraint to help the officer manage on-street parking allocation. In our work, we investigate the parking allocation problem in the context of a centralized model, where a centralized parking officer assigns parking locations by satisfying user priorities VOLUME 4, 2016 and maximizing the benefit of all users.
Pair Queries in Spatial Database. The pair queries in spatial database aim to discover some pairs of spatial objects with certain time or distance constraint. Corral et al. [14] address the problem of finding the K pairs of spatial objects formed from two data sets that have the K smallest distances between them, where each set is stored in a structure belonging to the R-tree family. However, due to ties of distances, the result of K-Closest Pair of these two point sets may not be unique for a specific pair. Unlike this situation, our parking allocation is certain for the Closest Pair relevant to each departing location. Zhou et al. [15] address the problem of querying the historical and spatial range close-pair moving objects, whose distance is closer than a user-specified distance constraint during the time interval TI and within the spatial range SR. Different from this query, parking allocation considers two kinds of static data objects, i.e., departing location and parking location, for the closet pair matching. U et al. [8] exploit space partitioning method to resolve the exclusive closest pairs problem, whose real application is the computation of car and parking slot assignments. In addition, joined data sets changing positions and content, and having a capacity constraint are also considered for parking allocation. U et al. [16] also propose an efficient algorithm for optimal capacity constrained assignment. Each customer is assigned to at most one provider. Every provider serves no more customers than its capacity. Meanwhile, the sum of Euclidean distances within the assigned providercustomer pairs is minimized. Different from the problem resolved above, our parking allocation focuses on point-topoint departing-parking location matching to maximize the service utility of all users. Chen et al. [17] retrieve the pairs with top-k maximal probabilities of being the closest pair given two uncertain datasets in which each spatial object is modeled by a set of sample points. Unlike this dataset, our parking allocation is schemed based on certain departing and parking locations.
Related Spatial and Spatial-textual Index. Indexing as grid or tree structures is a popular and effective method to answer many spatial queries like range search or visit the k-nearest neighbors, often under some query constraints. Li et al. [18] propose an efficient index called IR-tree, which supports top-k document retrievals leveraging the unified representation of textual and spatial relevances. Choudhury et al. [19] extend IR-tree and construct a text-first index structure SIF for batch processing top-k spatial-textual queries with the help of block based inverted file. Zhong et al. [20] present a height-balanced and scalable index, namely G-tree, to efficiently support KNN queries and keyword-based KNN queries based on the assembly-based method. Kucuktunc et al. [21] introduce a diverse browsing method for diverse k-nearest neighbor searches based on the popular distance browsing feature of R-tree. Tao et al. [22] design an inverted index, named SI-index, which extends the conventional inverted index to deal with multidimensional data and perform keyword-augmented nearest neighbor search in time. Cao et al. [23] further propose to retrieve a group of spatio-textual objects such that the group's keywords cover the query's keywords, and such that the objects are nearest to the query location and have the smallest inter-object distances, with the help of an IR-tree. In order to provide users with more options, the authors also propose to find the top-k groups covering all the query keywords and rank according to their costs. As the advantages of spatial index in coping with KNN query, we construct a new SCP-tree based on R-tree [24], to represent the parking locations and answer the MNPLA problem (see Definition 2).

III. PROBLEM FORMULATION A. MOTIVATION AND SYSTEM OVERVIEW
The Melbourne Transportation Council sets up in-ground sensor systems around Melbourne City Centre areas [25]. For each car parking area, the sensor can detect parking space availability and report it to the information centre periodically [26]. The system would send the message to the parking officer who is in charge of the parking allocation in some area [27], [28]. At a regular frequent time interval (e.g., 1 sec), the centralised system groups one or multiple new user queries that are received. The parking officer preprocesses some work in advance to analyze the users' personalized attributes and formulates the allocation priority for the users offline. When the users are ready to start their journeys and query for a parking spot, the parking officer will check the parking space availability and assign the parking locations according to the real-time departing locations, priority and destinations. During peak hours, the number of such users is likely to be more than 1, and the parking officer processing such users at a frequent interval as a group will improve the overall performance without any significant increase in the waiting time for response. Table 1 lists the notations used in this article. . Given a set of parking locations l p = (l p1 , l p2 , · · · , l pn ), a set of users U = (u 1 , u 2 , · · · , u m ) with their departing locations l d = (l d1 , l d2 , · · · , l dm ) and destination locations l s = (l s1 , l s2 , · · · , l sm ) as well as a time constraint specified for users to reach from the departing locations to the parking locations (driving time) and from the parking locations to their final destinations (walking time), the MNPLA problem is to retrieve a subset sl p ⊆ l p and assign the parking locations in sl p to mobile users based on (i) Geographical Preference Estimation (see Definition 7), which is used to determine the nearest parking location, (ii) user priority (see Definition 8), which is used to determine the optimal allocation order for minimizing the traveling time, and (iii) destinations, so that the allocation strategy can serve the maximum number of users within the time constraint and under the parking capacity constraint.

IV. PARKING LOCATION ALLOCATION SCHEME A. OVERVIEW OF SCP-TREE
R-tree is a height-balanced index structure that has been widely adopted to dispose different kinds of queries, such as range query, KNN query etc., by pruning unpromising branch nodes. Inspired by this, we aim to devise a similar spatial index on parking locations. To this end, we recursively partition the parking space into sub-regions and construct a hierarchical index tree structure. However, R-tree allows more overlap and coverage among sibling nodes. Thus it calls for an effective method that can provide a single traversal path and less coverage for parking locations, to achieve high query efficiency and low storage cost.
To address this issue, we exploit clustering techniques such that parking locations in the same cluster are closely located, and parking locations in different clusters are far from each other as much as possible. Therefore, parking locations in the dense regions should be put into the same node region to avoid cascading overlap and large coverage, whereas parking locations in the sparse regions can have a simpler sub-tree structure and better operation performance. The SCP-tree organizes parking locations according to such clustering results. Each node of the tree corresponds to a cluster. Each node is associated with a value called node capacity which denotes the number of available parking locations in that node region. As vehicles arrive and leave, the parking space availability of the node region (i.e., the node capacity) increases or decreases accordingly. In SCPtree, the parent node capacity is the summation of its child nodes' capacity. A single parking location capacity is "1" if it is available while it is "0" if it is unavailable. During query time, a node is visited only when its node capacity is greater than zero. Generally, SCP-tree has less overlap among sibling nodes than that of R-tree and its variants. In addition, due to the adjacent characteristic among parking locations in the same node, the coverage area of nodes is less than that of R-tree. In the following, we formally give the properties of SCP-tree: • The root node is the entire MBR region covering all the parking locations. • Each node stores a lower bounding driving time. It is computed by the minimum value from the driving time distances between all the departing locations of social-life-work-related users who stop in the locations indexed in its subtree and the parking locations of itself by the end of the query time (see Definition 3 as detailed explanation). This property is used to effectively do pruning the subtrees not within the driving time constraint. • Each node has a parking capacity. It is computed by summarizing the parking availability of its child nodes. This property is used to prune the subtrees that currently do not have available parking locations. • The interior nodes are the cluster regions where the number of parking locations is larger than a threshold, M 0 . Similar to the R-tree, the maximum number of the child nodes of an interior node is set to this value, M 0 . • The leaf nodes are the clusters where the number of parking locations is between m 0 and M 0 . We also set m 0 as the minimum number of parking locations in a leaf node similar to the R-tree. • A parking location is contained in only one upper parent node, thus the traversal path to a parking location during the query time is unique. Additionally, the parking location capacity is "1" if it is available while it is "0" if it is unavailable. • Unlike R-tree, SCP-tree is often an unbalanced tree.
Thus, the leaf nodes are generally not at the same level. For example, the node R 4 corresponds to the upper-right sub-region shown in Fig. 2, which includes parking locations l p5 , l p6 , l p7 , l p8 .

B. SCP-TREE CONSTRUCTION
In this article, we adopt the classic K-means [29] algorithm for clustering parking locations. Roughly, this method selects k parking locations as initial cluster centers. Then the distances between the parking locations and the cluster centers are computed, and each parking location is assigned to a cluster when the distance between this parking location and the center of the corresponding cluster is minimum. Then the center of the cluster is updated accordingly. The clustering procedure terminates when no update occurs to the cluster centers. Usually, the number of parking locations is quite larger than M 0 (i.e., n lp M 0 ) before clustering. As a result, the parking locations are divided into clusters.

Algorithm 1 : SCPTreeBuilt
Require: : S lp : the set of parking locations Ensure: : ndrt: the root node of constructed SCP-tree 1: , and cluster parking locations using K-means method, with each cluster containing k 0 (k 0 ≥ m 0 ) parking locations 4: foreach ϑ ∈ S cls do 5: set ϑ as a leaf node of ndrt 8: ϑ.T lo ← the minimum time value computed by Definition 3 9: else 10: nd cld ← SCPTreeBuilt(parking locations in ϑ) 11: set nd cld as a child node of ndrt 12: nd cld .T lo ← the minimum time value computed by Definition 3 13: end if 14: end for 15: end if Algorithm 1 presents the pseudo-code of our SCP-tree construction procedure. We first select k (m 0 ≤ k ≤ M 0 , m 0 = M 0 /2) parking locations as the initial cluster centers, and apply the K-means method to group parking locations into k clusters (line 3), with each cluster containing k 0 (k 0 ≥ m 0 ) parking locations. If the number of parking locations in a sub-cluster is within m 0 and M 0 , this subcluster is set as a leaf node of SCP-tree (lines 6-7). When a sub-cluster covers parking locations in the dense regions, the number of parking locations in that cluster is inevitably larger than the maximum value (i.e., M 0 ). We call such cluster as an overflow cluster, which needs to be re-clustered to form smaller clusters (lines 10). Additionally, for each child, a node stores a lower bounding driving time T lo , constructed by selecting the minimum value at each time point among all the parking locations indexed therein (line 8, 12) (see Definition 3). For each node, it also has a parking availability capacity, which is defined in Definition 5.
Recall that the relevant users that stop in the parking locations indexed in the subtree covering region R st by the end of the query time t 0 are independent for different query users with specific personalized attributes. To obtain a tight lower bounding driving time, we need the users having the similar social-life-work-related attributes with the query user u as large as possible since (i) the social-life-work-related users usually have a closer social connection, similar checkin activities as well as similar travel routine recommendation [30]; (ii) the users who have a closer social connection may have better trust in terms of their travel recommendation; (iii) the users who show more similar check-in behaviors should have more similar tastes with the active user, thus suggestions from those users are more worthy.
Definition 3. Lower Bounding Driving Time (LBDT). Let L d = {l d1 , l d2 , · · · , l d m } be the departing locations of a set of users U = {u 1 , u 2 , · · · , u m } who have a larger social-life-work-related attributes similarity with the query user u (see Definition 4) and stop in the parking locations indexed in subtree R st by the end of the query time t 0 . Let L p = {l p1 , l p2 , · · · , l p n } be the parking locations in the cluster region of R st . Then the lower bounding driving time T lo for R st is defined as where T imeDistDrive( , ) is the time required from l di to l pj by driving.
Definition 4. User Similarity (USI). Given two users u i and u j , Ye et al. [30] present the technique to derive the similarity between them based on both their social connections and similarity of their check-in activities. We follow the same similarity measure in this article, which can be calculated as below.
where α corresponds to the tuning parameter within the range of [0, 1]; F denotes the friend set, which refers to the socially connected friends of a user according to the location-based social networks; and L represents the interests set, which refers to the set of point-of-interests a user has life-workrelated check-in activities.
Definition 5. Node Capacity (NC). Let C nd be the parking availability capacity of node nd, and C cl = {C cl1 , C cl2 , · · · , C clz } be the parking availability capacity of the z child nodes of nd. Then C nd is defined as Space Complexity of SCP-tree. The space requirement of SCP-tree includes: (i) parking location information S pl , (ii) tree hierarchy S tr , and (iii) time and capacity constraint S tc . The overall storage for SCP-tree, denoted as S SCP −tree , can be estimated as S SCP −tree = S pl + S tr + S tc . Specifically, S pl involves |L| parking locations, in total having |W | parking location information. As SCP-tree is not a balanced tree, for L st = |L| − |L | + |u| nodes in the first balance layer of SCP-tree, the height is log f L st , where |L | is the number of parking locations not at the first balance layer, and |u| is the number of parent nodes generated at the first balance layer. Assume the root is at level 0, the number of SCP-tree nodes in the layers higher than and equal to the first balance layer is given as f h . For each parent node j ∈ u, it can be considered as the root node of another sub-index tree and a similar height can be computed for j through finding the first balance layer. This iteration computation process terminates until all the remaining leaf nodes are in the same level. Given p as the reducing scale of the number of nodes in the first balance layer in each height computation process of the following sub-index trees, the number of nodes in the first balance layer in the following sub-index trees is approximately as Lst p i (i = 0, 1, · · · ). Thus, S tr can be given as i≥0 f h . Moreover, since each node is associated with one lower bounding driving time and a parking available capacity, the storage for all "lower bounding driving time" and "parking availability capacity" is Therefore, the overall size of SCP-tree can be given as below.
Time Complexity of SCP-tree. Given p as the reducing scale of the number of parking locations in each clustering process, the number of parking locations in the following sub-cluster regions is approximately as n p i (i = 0, 1, · · · ) from the high level to the low level, where n is the total number of parking locations. The time complexity of clustering parking locations is O( n p i × k × t), where k is the number of clusters and t is the iterative times. Usually, k n and t n. In our clustering algorithm, k is a constant and t is typically quite small. Thus, the time complexity of Algorithm 1 is O(n).

C. PARKING LOCATION ALLOCATION
In our parking location allocation scheme, the most common objective is to minimize the total distance of all the vehicles' allocation, that is also to maximize the total service utility across all the users in descending of user priority. Here, a kernel density estimation (KDE) [31], [32], which can be used for arbitrary distribution estimation and without the assumption that the form of the distance distribution is known, is employed to personalize the geographical preference for each user. The intuition is that a user's parking behavior is significantly affected by the geographical positions of parking locations, which have been considered as a major impact factor in minimizing his/her traveling time. Definition 6. Geographical Preference Model (GPM). Given a parking region composed of some parking locations, let U = {u 1 , u 2 , · · · , u m } be the set of m users that have visited this parking region, and D be the set of distances between each pair of user locations. For a new user u i , we define d ij = ||u i , u j || as the Euclidean distance between u i and u j (∈ U ). The kernel density of d ij is defined as: Definition 7. Geographical Preference Estimation (GPE). The geographical preference of u i on parking region Rg, denoted by GeoRating(u i , Rg), can be calculated by taking the average of all its probability densities, i.e., Definition 8. User Priority (PR). Given a set of attributes A = {a 1 , a 2 , · · · , a n } that a user u i has, let W ui,aj be a weighting factor of parking officer's semantic importance on a j of u i . Some possible semantic weights are extremely important, very important, important, and somewhat important. The overall personalized trade-off priority u pri of u i endowed by the parking officer can be described using the individual personalized attribute a, the preference weight w and the aggregation operator ⊗ given as u pri = (W 1 · a 1 ) ⊗ (W 2 · a 2 ) ⊗ · · · ⊗ (W n · a n ) In our allocation scheme, we assume that a user provides a profile before he or she starts moving. A profile should cover all categorical attributes, such as the personalized attribute, location, distance etc. And such preference order information summarized from the profiles of different users is stored by the officer for parking allocation. In the following, we give an example for explanation.
Example 9. Suppose a user Alice has the following preferences: • The distant departing location regions are preferable because it may require to spend more time before parking the car. These preferences can be expressed as an order between the semantic distances: remote medium near. The weight order of these preferences, for example, can be expressed as W remote = 0.8 > W medium = 0.5 > W near = 0.2. • She prefers to drive slowly because of her senior age.
This means that there exist preference relationships between the semantic attributes: old middle-aged young. The weight order of these preferences, for example, can be expressed as W old = 0.8 > W middle−aged = 0.5 > W young = 0.2.
It is note worthy that in peak hours, a lot of users will be requesting for parking. To help parking allocation in peak hour, some analysis and decision are required as soon as VOLUME 4, 2016 possible by sharing and reducing computations. To achieve this goal, we can divide the users into groups using their approximate priorities. Therefore, a decending queue can be constructed based on both the users' and groups' priority. In the following, we extend the Geographical Preference Estimation of a single user to the Geographical Preference Estimation for a group of users. as the average Euclidean distance between each user in ug i and u j (∈ U ), where N ugi is the number of users in ug i . The kernel density of Ad ij is defined as: Definition 11. Group Geographical Preference Estimation (GGPE). The geographical preference of ug i on parking region Rg, denoted by GeoRating(ug i , Rg), can be calculated by taking the average of all its probability densities, i.e.,

Algorithm 2 : ParkingLocationAllocation
Require: S lp : the set of parking locations Sur: a set of users θ td : the driving time constraint θtw: the walking time constraint Ensure: S npl : the set of nearest parking locations to each user 1: foreach u i ∈ Sur do 2: upr i ← the priority computed from Eq. 7 3: end for 4: upq ← the user priority group queue constructed from upr i in descending order 5: SCP-tree ← SCPTreeBuilt(S lp ) 6: ndrt ← the root node of SCP-tree 7: S cl ← the child nodes of ndrt 8: upq(θtw) ← ParkingLocationAllocationDestination(S lp , S cl , Sur, θtw) 9: foreach upq(ϕ ∈ S cl , θtw) ∈ upq(θtw) do 10: foreach ϕ ∈ upq(ϕ ∈ S cl , θtw) do 11: if ϑ = u i then 12: l nf i ← SingleUserParkingAllocation(u i , θ td , ϕ) 13: lnp i ← the nearest parking location in l nf i to the departing location of u i 14: S npl ← S npl lnp i 15: else 16: l nf i ← SingleGroupUserParkingAllocation(ug i , θ td , ϕ) 17: lnp i ← the nearest parking location in l nf i to the departing location of each user in u gi 18: S npl ← S npl lnp i 19: end if 20: end for 21: end for Algorithm 2 shows the details of parking location allocation for a set of users. We first compute the priority for each user (lines 1-3), which is used to serve the maximum number of users in terms of distance. The priority queue is maintained in descending order of the users' or user groups' priority value. For the users or user groups in this priority queue, we re-divide them into several sub-priority queues by computing the traveling time between their destinations and the branch node parking regions (line 8). For the users or user groups in each sub-priority queue, we search the nearest leaf node according to Algorithm 4 (line 12) and 5 (line 16), which introduce the parking location allocation mechanism for a single user and a group of users, respectively. Since more than one parking location may be allocated to a user, we select the nearest one as the final allocation result. As the time complexity of Algorithm 3 is O(n ur ), and the time complexity of Algorithm 4 and Algorithm 5 is O(n) aftermentioned, the time complexity of parking location allocation can be derived as O(n ur + n ur × n), where n ur is the total number of users and user groups, and n is the number of parking locations. Usually, n ur is a constant and n ur n. Therefore, the time complexity of Algorithm 2 can be derived as O(n).

14: end for
The steps for re-dividing the users or user groups in descending order in the priority queue are given in detail in Algorithm 3, which aims to guarantee the walking time satisfying the query requirement. Through computing the traveling time between the users or user groups' destinations and the branch node parking region (line 7) according to Eq. 10, each user or user group can be divided into a subpriority queue correlated with a child branch region of the root node (line 8). The time complexity of Algorithm 3 is O(|u pq | · |S cl |), where |u pq | represents the number of members in the priority queue and |S cl | represents the child nodes' number of the root node. Since |u pq | ≤ n ur , |S cl | ≤ M 0 (M 0 is a constant), the time complexity of Algorithm 3 in the worst case is O(n ur ), where n ur is the number of users.
Definition 12. Walking Time (WT). Let R s be a destination region including S = {l s1 , · · · , l sm } locations, R p be a parking region including P = {l p1 , · · · , l pn } locations. The walking time from R s to R p with a traveling speed v is defined as: [1,n] ||lsi,lpj || v (10) GeoRating(ui, ci) ← compute the geographical preference estimation of ui to ci according to Eq. 6 along SCPtree 8: if GeoRating(ui, ci) > GeoRating then 9: c0 ← ci GeoRating ← GeoRating(ui, ci) 12: end if 13: end for 14: l nf i ← SingleUserParkingAllocation(ui, θ td , c0) The steps for processing the parking location allocation for a single user are given in detail in Algorithm 4: (i) We first determine the lower bounding driving time of each node (line 4), which is used to serve the users within the driving time constraint. (ii) The Geographical Preference Estimation to the nodes that satisfy the driving time constraint and parking capacity constraint are computed for the user u i along the SCP-tree (line 5-11) until the nearest leaf node to u i is returned (line 13). The time complexity of Algorithm 4 is O(n), where n is the number of parking locations.
The pseudocode for allocating the parking locations for a group of users is shown in Algorithm 5. We first determine the lower bounding driving time of each node (line 11), which is used to serve the users within the driving time constraint. The user group computes the Geographical Preference Estimation to the nodes that satisfy the driving time constraint along the SCP-tree (line 12-18) until the nearest leaf node to ug i is returned (line 20). When one of the child nodes of a certain non-leaf node cannot have more parking locations than that required, the parking location allocation of a single user is performed for each user in ug i (line 23) until the nearest leaf node to each user in ug i is returned. As the time complexity of Algorithm 4 is O(n) afore-mentioned, the time complexity of Algorithm 5 can be derived as O(n), where n is the number of parking locations.
Example 13. Here we use an example to illustrate the traversal process over SCP-tree shown in Fig. 2. When users' priority is determined by Definition 8, we carry on traversing SCP-tree to achieve the parking location of current user u in Fig. 2. Supposed that the walking time from u destination to parking region R 1 is within the time constraint θ tw , we carry on searching the parking location along R 1 branch. We assume that T lo at each node R i (i ∈ [0, 8]) is lower than the driving time threshold θ td specified by the query and all the parking locations are available currently. First, we access R 3 and R 4 , and compute GeoRating(u, R 3 ) > GeoRating(u, R 4 ) based on u 1 , u 2 , u 3 and u 4 , who have

Algorithm 5 : SingleGroupUserParkingAllocation
Require: ug i : a group of users having an approximate priority θ td : the driving time constraint ndst: a subtree node in SCP-tree Ensure: l nf i : the nearest leaf node to each user in ug i 1: S cld ← the child nodes of ndst 2: GeoRating ← 0 3: f lag ← 0 4: foreach c i ∈ S cld do 5: if Nc i > Nug i then 6: flag=flag+1 7: end if 8: end for 9: if f lag = N S cld then 10: foreach c i ∈ S cld do 11: T loi ← the lower bounding driving time of c i 12: C ci ← the parking available capacity of c i 13: if T loi < θ td and C ci = 0 then 14: GeoRating(u gi , c i ) ← compute the geographical preference estimation of u gi to c i according to Eq. 9 along SCP-tree 15: if GeoRating(u gi , c i ) > GeoRating then 16: c 0 ← c i 17: end if 18: GeoRating ← GeoRating(u gi , c i ) 19: end if 20: end for 21: l nf i ← SingleGroupUserParkingAllocation(ug i , θ td , c 0 ) 22: else 23: foreach u i ∈ u gi do 24: l nf i ← SingleUserParkingAllocation(u i , θ td , ndst) 25: end for 26: end if already visited parking locations l p1 , l p3 , l p5 and l p7 . Finally, we acquire the nearest parking location l p1 . When the parking available capacity of R 4 is "0", R 4 is pruned and we focus on R 3 for the nearest parking location allocation.

A. EXPERIMENTAL SETUP
Our real parking locations dataset is from Melbourne City Centre, which consists of 2908 parking locations [33], [34]. In this experiment, we use the parking space availability data from the on street parking bay sensors events records recently published online, that include different bays, streets, status as well as spatial information such as the latitude and longitude of the parking locations (see Table 2 as an example). Fig. 4(a) reveals the parking location availability in Melbourne City Centre within a certain time interval. Further, we extract 100 users' departing locations that disperse in the administrative regions of Melbourne City during 2016/1/4-2016/1/10 8:00-17:00. The parking locations and extracted departing locations are visualized in Fig. 4(b). In addition, we also extract 130 users' destination locations from the neighborhood of parking locations. The user percent for each attribute combination shown in Table 3 Table 4 as an example). And the values tested for each parameter in our experiment are detailed in Table 5, where the default parameter values are given in bold.
For the sake of understanding the effectiveness of SCPtree, time constraints, GPE and priority, the four methods with progressive constraints are tested in our experiment (see Table 6), where "yes" indicates that the method has the corresponding constraint, otherwise, it is labeled as "no". Meanwhile, we also give another three typical baseline methods to illustrate the performance of proposed method: • BPMT: An allocation scheme that provides a pricing mechanism to guarantee the optimal social welfare by using ad auction theory [7]. • NHEQ: An allocation scheme that assigns vehicle-slot pair prices, which guarantees that no driver will pay a higher total cost than the one she can obtain by behaving selfishly [6]. • ECP: An allocation scheme that recursively searches for the closest pair objects from two data sets [8].
In the following, we aim to compare these methods in terms of allocation time, I/O cost, traveling time and service utility. Meanwhile, we also test and analyze the parking allocation performance about group based allocation scheme, which includes the following aspects: group and non-group based allocation time (GAI, AI), group and non-group based traveling time (GTT, TT), group and non-group based ac-  cessed pages (GAP, AP), as well as group and non-group based service utility (GSU, SU).
To evaluate the service utility for allocation scheme, we adopt the following three kinds of utilities similar to that in Literature [12]: This utility reflects the preference of user u i towards the parking location p j . It can be estimated with the categorically stated parking experience relevant to the geographical preference and personalized attributes. • User-related Utility (ξ u (u i , p j )): This utility will change when other users with similar tastes in parking location p j change. Specifically, we define user-related utility in the following form: where T k j indicates the users parking in p j during the trajectories T r j i connecting u i and p j , and U SI(u i , u i ) is the social similarity of u i and u i . Intuitively, for a user u i , sharing with other high-similarity users for a larger portion of T r j i , will lead to a higher user-related utility.
• Trajectory-related Utility (ξ t (u i , p j ) ∈ [0, 1]): This utility is to measure the satisfaction level of the user u i towards the routes T r j i . In general, the trajectory-related utility decreases when the extra travel cost is incurred (e.g., caused by detours, weather, traffic congestion etc) for u i parking in p j . We define the trajectory-related utility as

1) Comparison with progressive methods
Effect of User Number. We begin by studying the impact of user number from 10 to 130. In this set of experiment, the parking location number is set as 2908. From Fig. 5(a), we can see the method NNNN without any order and pruning optimization performs worst in terms of parking location allocation time. With the help of SCP-tree, the method NNNS is at least 10 times faster than NNNN. This means that the SCP-tree gives a better pruning effect on the parking location search with geographical approximation. When pruning in the SCP-tree, we adopt the Geographical Preference Estimation, lower boundary driving time and node capacity as the three criteria to accurately carry on judgment. This eliminates the distant parking locations that are not within the time constraints. The experiment results of method N GT S verify this effectiveness. Additionally, we design user priority based on the distance and personalized attributes. Leveraging the order of user priority, the allocation process incurs less comparison and adjustment for maximizing the benefits of all  users. Overall, the approach P GT S has a better improvement than the other three progressive methods in terms of parking location allocation time. We also notice that the parking location allocation time increases with the number of users in the order of NNNN NNNS NGTS PGTS. This is to be expected since the parking officer has to do more work to consider all the users' requirements.
Here, we study the distribution of average traveling time in terms of the number of users. Fig. 5(b) compares the average traveling time for the four approaches. Note that, the four approaches have a very similar traveling time distribution with the increase of user number. This demonstrates the superiority of our approach, as the other candidate approaches provide an approximately optimal allocation result in about 1100s. Some factors, such as weather, age, habit, road condition etc, have an impact on the traveling time. Compared with the parking location allocation time, the difference value of average traveling time is very small, at most 100s.
Next, we evaluate index I/O cost of the four approaches in Fig. 5(c). It is clear that all approaches follow a linear trend with the number of users, consistent to the behavior determined in our cost model. Meanwhile, we can also see a significant difference in terms of magnitudes among all those approaches due to the efficient pruning-based spatial index search algorithm facilitated by the Geographical Preference Estimation and user priority.
We also evaluate the service utility of our proposed approach in terms of the number of users in Fig. 5(d). As the user number increases, the generated service utility also grows since more users' benefits are maximized for allocating the nearest available parking locations. Since the service utility is evaluated in terms of user preference towards the parking location and route, as well as user similarity, PGTS performs best among the four methods.
In summary, we observe that the parking location allocation time, I/O cost as well as service utility present an increasing trend with the user number for each approach. The method NNNN has the largest parking allocation time, I/O cost, and the minimum service utility. The next worst method is N N N S, and the best method is P GT S.   Effect of Traveling Speed.    we compare the performance of four progressive methods in different time divisions (see Table 7). In this set of experiments, we adopt the default parameters values given in Table  5. The results present the similar variant trend for parking allocation performance as that without time division.
2) Comparison with baseline methods Fig. 6 illustrates the experimental results on the comparison with the baseline methods without time division. The results are quite similar to that of the previous experiments. P GT S demonstrates a significant advantage over the other methods in terms of the overall parking location allocation time, average traveling time, I/O cost and service utility, while the four methods have the almost similar performance variant trend under different parameter settings. In all cases, P GT S efficiently allocates the parking locations and requires much less I/O cost as well as generates a higher service utility than BP M T, N HEQ and ECP for varying the number of users, the number of parking locations and traveling speed. This can be attributed to the ideas that the layer partitions for parking locations are at an arbitrary order in BP M T while N HEQ executes the auction algorithm for pricing parking locations in rounds or iterations beginning with arbitrary allocations and prices. Meanwhile, ECP only considers the pair nearest distance for parking location allocation. A significant adjustment is still required for maximizing all the users' benefits since the users' personalized attributes also have an important impact on the traveling time. Moreover, P GT S reduces the average traveling time compared to BP M T , N HEQ and ECP since they do not consider any time and personalized attribute constraint as the preference allocation order in the allocation process. The intuition behind is that the factors, such as the time and personalized attributes, can impact and postpone the traveling to some extent. To further illustrate the parking allocation performance, we compare the performance of four baseline methods in different time divisions (see Table 8). In this set of experiments, we also adopt the default parameter values given in Table  5. The results present the similar variant trend for parking allocation performance as that without time division.

3) Comparison with group-based allocation method
In the following, we present group based allocation performance in peak hours. Fig. 7 shows the experiment results for varying the number of users, the number of parking locations and traveling speed. In all cases, group based allocation method requires less allocation time and I/O cost than that of the non-group allocation scheme, while having a higher service utility and approximate traveling time trend. The reason behind is that the users with approximate priority are grouped together, which can facilitate the officer to make some analysis and decision as soon as possible by sharing and reducing some of the computations when querying along the SCP-tree. Meanwhile, the user group provides a higher user-related utility since "group" indicates that the users in this group have a higher social similarity and "users gathering together at peak hours" indicates they have a higher probability to park in the regions along the same or adjacent trajectories.

VI. CONCLUSION
In this article, we propose a novel parking location allocation scheme for mobile users to support the sustainability in green transportation systems. The focus of this work is to construct an SCP-tree by incorporating a lower boundary driving time and a node parking capacity into the design mechanism. Furthermore, we present a Geographical Preference Estimation based search strategy along the branch nodes that are within the walking time requirement in descending order of user priority. We evaluate the performance with four progressive methods and also compare our approach against three baselines. The experimental results show that our proposed method has a theoretical and practical superiority in the parking allocation performance. However, the method has to be executed by parking officer continuously for efficient allocation. As future work, we would like to extend this paper to provide means to automatically and intelligently realize the parking allocation combined with the technology of Internet of Things and machine learning.