Question

I have a database of animals, each with many attributes ranging from 0 to 1– these attributes are things like size, speed, hairiness, etc. Given an input set of attributes, and weights for each type of attribute, I need to find the “closest” match in the set of animals. Is there an algorithm that accomplishes this in better than O(n) time?

What I’m specifically trying to do is find suitable textures for “animals” produced by a genetic algorithm in a game, by matching them to animals that already exist. By “closest,” I mean the animal whose weighted sum of attribute differences is minimal. The database and weights are known at application launch time, so a lot of time can be invested towards preparing the data.

I’ve found algorithms on string matching and product matching given user preferences, but either I’m not finding what I’m looking for or I’m not understanding how to reapply such concepts to my dilemma. Perhaps there’s something from the world of graph theory to help me out?

Any help would be greatly appreciated!

Answer 1

You could treat the items as points in a high-dimensional space, and insert them all into a BSP-tree, such as a k-d tree. To use the attribute-weights, you just need to multiply them by the corresponding coordinate: (w1*x, w2*y, ...)

Preparation: (from wikipedia, python code)

def kdtree(point_list, depth=0):

    if not point_list:
        return None

    # Select axis based on depth so that axis cycles through all valid values
    k = len(point_list[0]) # assumes all points have the same dimension
    axis = depth % k

    # Sort point list and choose median as pivot element
    point_list.sort(key=lambda point: point[axis])
    median = len(point_list) // 2 # choose median

    # Create node and construct subtrees
    node = Node()
    node.location = point_list[median]
    node.left_child = kdtree(point_list[:median], depth + 1)
    node.right_child = kdtree(point_list[median + 1:], depth + 1)
    return node

Search: (from gist, based on the wikipedia algorithm)

# method of the Node-class

def closest_point(self, target, point, best=None):
    if target is None:
        return best

    if best is None:
        best = target

    # consider the current node
    if distance(target, point) < distance(best, point):
        best = target

    # search the near branch
    best = self.child_near(point).closest_point(point, best)

    # search the away branch - maybe
    if self.distance_axis(point) < distance(best, point):
        best = self.child_away(point).closest_point(target, point, best)

    return best

---

Read more:

• High Dimensional Search and the NN Problem (blog article)
• Closest Point Search in High Dimensions by Nene and Nyar.
• Nearest Neighbor Search in Multidimensional Spaces by Tsaparas