如何使以下代码更快？

Question

I am trying to optimize code for a challenge in codewars but I am having some trouble making it fast enough. The kata in question is this . The description is explained in a detailed way in the link I have given and I do not reproduce it here not to bloat the question. My attempted code is the following (in python)

# first I define the manhattan distance between any two given points
def manhattan(p1,p2):
return abs(p1[0]-p2[0])+abs(p1[1]-p2[1])

# I write a function that takes the minimum of the list of the distances from a given point to all agents

def distance(p,agents):
return min(manhattan(p,i) for i in agents)

# and the main function

def advice(agents,n):

# there could be agents outside of the range of the grid so I redefine agents cropping the agents that may be outside
agents=[i for i in agents if i[0]<n and i[1]<n]
# in case there is no grid or there are agents everywhere
if n==0 or len(agents)==n*n:
    return []
# if there is no agent I output the whole matrix
if agents==[]:
    return [(i,j) for i in range(n) for j in range(n)]
# THIS FOLLOWING PART IS THE PART THAT I THINK I NEED TO OPTIMIZE
# I define a dictionary with key point coordinates and value the output of the function distance then make a list with those entries with lowest values. This ends the script
dct=dict( ( (i,j),distance([i,j],agents) ) for i in range(n) for j in range(n))
# highest distance to an agent
mxm=max(dct.values())
return [ nn for nn,mm in dct.items() if mm==mxm]

The part I think I need to improve is marked in the code above. Any ideas of how to make this faster?

Answer 1

Your algorithm is doing a brute force check of all positions against all agents. If you want to accelerate the process, you have to use a strategy that allows you to skip large parts of these nxnxa combinations.

For example, you could group the points by distance in a dictionary starting with all the points at the largest possible distance. Then, go through the agents and redistribute only the farthest points to closer distances. Repeat this process until the farthest distance retains at least one point after going through all agents.

This would not eliminate all the distance checks but it skips a lot of distance computations for points that are already known to be closer to an agent than the farthest ones.

Here's an example:

def myAdvice2(agents,n):
    maxDist    = 2*n
    distPoints = { maxDist:[ (x,y) for x in range(n) for y in range(n)] }
    index      = 0
    retained   = 0
    lastMax    = None
    # keep refining until farthest distance is kept for all agents
    while retained < len(agents):
        ax,ay = agents[index]
        index = (index + 1) % len(agents)

        # redistribute points at farthest distance for this agent         
        points  = distPoints.pop(maxDist)
        for x,y in points:
            distance = min(maxDist,abs(x-ax)+abs(y-ay))
            if distance not in distPoints:
               distPoints[distance] = []                   
            distPoints[distance].append((x,y))
        maxDist = max(distPoints) 

        # count retained agents at MaxDist      
        retained  += 1
        # reset count when maxDist is reduced 
        if lastMax and maxDist < lastMax : retained = 0
        lastMax   = maxDist

    # once all agents have been applied to largest distance, we have a solution
    return distPoints[maxDist]

In my performance tests this is about 3x faster and performs better on larger grids.

[EDIT] This algorithm can be further accelerated by sorting the agents based on their distance to the center. This will ensure that points at the farthest distances are eliminated faster because agents at central positions cover more ground.

You can add this sort at the beginning of the function:

agents = sorted(agents, key=lambda p: abs(p[0]-n//2)+abs(p[1]-n//2))

This will yield a 10% to 15% improvement on speed depending on the number of agent, their positions and the size of the area. Further optimisations could determine when this sort is worthwhile based on data.

[EDIT2] if you're going to use a brute force approach, leveraging parallel processing (using the GPU) could give suprizingly fast results.

This example, using numpy, is 3 to 10 times faster than my original approach. I'm guessing that this will only be the case up to a point (having more agents slows it down considerably) but it was much faster in all small scale tests I did.

import numpy as np
def myAdvice4(agents,n):
    ax,ay     = [np.array(c)[:,None,None] for c in zip(*agents)]
    px        = np.repeat(np.arange(n)[None,:],n,axis=0)
    py        = np.repeat(np.arange(n)[:,None],n,axis=1)
    agentDist = abs(ax - px) + abs(ay - py)
    minDist   = np.min(agentDist,axis=0)
    maxDist   = np.max(minDist)
    maxCoord  = zip(*np.where(minDist == maxDist))
    return list(maxCoord)

Answer 2

您可以将sklearn.metrics.pairwise_distances与 manhattan 指标一起使用。