2019阿里校招测评题，光明小学完全图最短路径问题(python实现)

题目：光明小学的小朋友们要举行一年一度的接力跑大赛了，但是小朋友们却遇到了一个难题：设计接力跑大赛的线路，你能帮助他们完成这项工作么？
光明小学可以抽象成一张有N个节点的图，每两点间都有一条道路相连。光明小学的每个班都有M个学生，所以你要为他们设计出一条恰好经过M条边的路径。
光明小学的小朋友们希望全盘考虑所有的因素，所以你需要把任意两点间经过M条边的最短路径的距离输出出来以供参考。

你需要设计这样一个函数：
res[][] Solve( N, M, map[][]);
注意：map必然是N * N的二维数组，且map[i][j] == map[j][i]，map[i][i] == 0，-1e8 <= map[i][j] <= 1e8。（道路全部是无向边，无自环）2 <= N <= 100, 2 <= M <= 1e6。要求时间复杂度控制在O(N^3*log(M))。

map数组表示了一张稠密图，其中任意两个不同节点i,j间都有一条边，边的长度为map[i][j]。N表示其中的节点数。
你要返回的数组也必然是一个N * N的二维数组，表示从i出发走到j，经过M条边的最短路径
你的路径中应考虑包含重复边的情况。

一、求解

先来说一下求解这一题的思路，这个问题的本质就是M步无向图的最短路径遍历，一般求解最短路径问题，我们首先想到的就是采用递归实现。

已知有N个节点，求解从节点i到节点j之间的M步的最短路径问题，我们可以把M步分解成1步和M-1步：

1、假设存在节点k，且k节点不同于节点i,节点j，第一步求解节点i到节点k之间的1步最短路径

2、剩下M-1步，可以看做求解节点k到节点j之间的M-1步最短路径问题

3、当k取不同值时，我们会得到多个距离值，选取最小的一个距离值

# -*- coding: utf-8 -*-

"""

Created on Fri Aug  3 08:54:35 2018

@author: zy

"""

import numpy  as np

def Solve(maps,M):

    '''

    由N个节点两两连接组成路径，选取从节点i->节点j之间的最短M条路径

    param:

        maps:二维数组，由两两节点之间的路径长度组成

        M:表示所经过的路径个数

    '''

    '''

    输入校验

    '''

    if not isinstance(maps,(list,np.ndarray)):

        raise ValueError('输入参数maps数据类型必须是list或者numpy.array')

    if len(maps.shape) != 2:

        raise ValueError('输入参数maps为二维数组')

    if maps.shape[0] != maps.shape[1]:

        raise ValueError('输入二维数组maps行数和列数要求一致')

    #计算节点的个数

    N = maps.shape[0]    

    if N<2 or N>100:

        raise ValueError('输入二维数组maps行数必须在2~100之间')

    if M<2 or M>1E6:

        raise ValueError('输入参数N的值必须在2~1e6之间')

    #输入二维数组数值校验

    for i in range(N):

        for j in range(i,N):

            if maps[i][j] != maps[j][i]:

                raise ValueError('输入二维数组maps必须是对称的')

            if maps[i][j] < -1e8 or maps[i][j] > 1e8:

                raise ValueError('二维数组maps的元素值必须在-1e8~1e8之间')

            if i==j:

                if maps[i][j] != 0:

                    raise ValueError('二维数组maps的对角元素值必须是0')

    #用于保存i->j的路径值

    res = np.zeros_like(maps)

    #计算节点i->j的最短路径

    for i in range(N):

        for j in range(i,N):

            res[i][j] = MinPath(maps,M,i,j)

            res[j][i] = res[i][j]

    return res

def  MinPath(maps,M,i,j):

    '''

    计算i->j的最短路径

    '''

    #递归终止条件

    if M == 1:

        return maps[i][j]

    '''计算i->j的最短路径'''

    N = maps.shape[0]

    #用于保存i->j的可能路径长度

    length = np.zeros(N)

    #遍历从k->j的最短路径

    for k in range(N):

        if k != i and k != j:

            #k->j的M-1条最短路径 + i->k的一条路径

            length[k] = MinPath(maps,M-1,k,j) + maps[i][k]

    #进行排序，过滤掉为0的值

    length = np.sort(length)

    for  i in length:

        if i != 0:

            return i

if __name__ == '__main__':

    #maps = np.array([[0,2,3],[2,0,1],[3,1,0]])

    maps = np.array([[0,2,3,4],

                     [2,0,1,3],

                     [3,1,0,2],

                     [4,3,2,0]

            ])

    M = 3

    result = Solve(maps,M)

    print(result)

二、时间复杂度分析

我们来分析一下该算法的时间复杂度。

先来分析一下递归函数MinPath(maps,M,i,j):

1、函数的规模为M

2、当规模是1时，函数结束

3、假设T(M)表示规模为M的问题所需要的步骤数

算法的递归方程为：T(M) = (N-2)T(M - 1) +3N+6

注释：3N+6表示规模毎减少一次，所做的步骤数

if M==1: 1次
N=maps.shape[0] 1次
length = np.zeros(N) 1次
for k in range(N): N次
if k != i and k != j: N次
+ maps[i][k] 当i==j时 N-1次，否则N-2次我们取N-2次
length = np.sort(length) 1次
最后的for循环 2次或者4次我们取4次

迭代展开：T(M) = (N-2)T(M - 1) + 3N+6

=(N-2)[(N-2)T(M-2) + 3N + 6] + 3N+6

=(N-2)²T(M-2) + (N-2)(3N+6) + 3N+6

=(N-2)³T(M-3) + (N-2)²(3N+6) + (N-2)(3N+6) + 3N+6

=....

=(N-2)^(M-1) + (N-2)^(M-2)(3N+6)+...+3N+6

=(N-2)^(M-1) + [(N-2)^(M-1)(3N+6) - 3N-6]/(N-3)

= O((N-2)^(M-1))

Solve函数中递归函数循环的次数为N(1+N)/2，所以算法的复杂度为O(N²(N-2)^(M-1))。并没有满足题目的要求，更好的求解方法我还没有想到，有了解的大佬可以告诉小弟。

参考文章：

[1]递归函数时间复杂度分析(转)

[2]2019阿里校招测评题，光明小学完全图最短路径问题(c版本)