Python 寻求更好的动态规划解，以找到复杂度更低的算法

我在一次采访中遇到了这个问题

您位于无限二维栅格中，可以在其中的8个方向中任意一个方向移动：

（x，y）至 （x+1，y）， （x-1，y）， （x，y+1）， （x，y-1）， （x-1，y-1）， （x+1，y+1）， （x-1，y+1）， （x+1，y-1） 您将获得一系列需要涵盖的要点。给出你能实现它的最小步骤数。你从第一点开始

例如：

输入：[（0,0）、（1,1）、（1,2）] 产出：2 从（0,0）移动到（1,1）需要一个步骤。从（1，1）移动到（1，2）还需要一个步骤

我能够用记忆（DP）技术提出一个递归解决方案，保留访问点列表，但似乎仍然不是最佳的。即使面试之后，我仍在考虑更好的解决方案。有谁能想出比我更好的解决办法吗？我需要帮助

    # @param X : list of integers
    # @param Y : list of integers
    # Points are represented by (X[i], Y[i])
    # @return an integer
        def coverPoints(self, X, Y):
            if len(X) == 1:return 0
            def odist(A, B): #to calculate shortest distance between a pair of points
                min_d =  0 if abs(A[1]-B[1]) > abs(A[0]-B[0]) else 1
                return abs(A[min_d]-B[min_d]) + (abs(A[1-min_d]-B[1-min_d])- abs(A[min_d]-B[min_d]))

            D = {}

            def rec(curL, last, dist):
                if D.get((tuple(curL), dist), False) != False:return D[(tuple(curL),dist)]
                if len(curL) == 0:return dist
                else:
                    s = sys.maxsize
                    for id, i in enumerate(curL):
                        newL = curL[:id] + curL[id+1:]
                        s = min(s, rec(newL, id, odist( (X[last], Y[last]), (X[curL[id]], Y[curL[id]]) )))
                    D[(tuple(curL),dist)] = dist + s
                    return dist + s


            s = rec([i for i in range(len(X))], 0, 0)
            return s

---

必须是DP吗？另外，很抱歉没有完全查看，但是您当前解决方案的时间复杂度（或您期望的复杂度）是多少？您能在代码中添加一些注释吗？试图理解变量代表什么。我的意思是，有一个明显的

n^2（logn）

解决方案，但您的代码有点难理解。我的代码逐字计算所有排列（n！），但减少子元素中的冗余计算。你能分享你的n^2（logn）逻辑吗？它必须是DP吗？另外，很抱歉没有完全查看，但是您当前解决方案的时间复杂度（或您期望的复杂度）是多少？您能在代码中添加一些注释吗？试图理解变量代表什么。我的意思是，有一个明显的

n^2（logn）

解决方案，但您的代码有点难理解。我的代码逐字计算所有排列（n！），但减少子元素中的冗余计算。你能分享你的n^2（logn）逻辑吗？