Nearest Neighbor Algorithm

"""
    最近邻算法：从任一城市开始，总是选择还未参观的城市中最近的那座，再选择路径中最短的那条
    具体如下：
    1. 从未参观的城市中选择距离当前路径最近的城市C
    2. 将C添加到路径末尾，并从未参观的城市中移除C
"""

def nn_tsp(cities):
    start = first(cities)
    tour = [start]
    unvisited = set(cities - {start})
    while unvisited:
        C = nearest_neighbor(tour[-1], unvisited)
        tour.append(C)
        unvisited.remove(C)
    return tour

def nearest_neighbor(A, cities):
    """
    寻找cities中距离城市A最近的城市
    :param A:
    :param cities:
    :return:
    """
    return min(cities, key=lambda c:distance(c, A))

"""
    虽然近似算法的速度很快，但是得到的却不是最短的距离
    搞清楚nn_tsp的起始城市，可能会有助于我们明白它为什么会“出错”
"""

def plot_tour(tour):
    """
    将起始的城市标记为红色
    :param tour:
    :return:
    """
    start = tour[0]
    plot_lines(list(tour) + [start])
    plot_lines([start], 'rs')

def length_ratio(cities):
    """
    计算nn_tsp与alltours_tsp路径长度的比值
    :param cities:
    :return:
    """
    return tour_length(nn_tsp(cities)) / tour_length(alltours_tsp(cities))

"""
    优化：nn_tsp固定了起始城市，很可能使得更优值丢失
    我们可以重复该算法，计算以任一城市为起点的最近邻算法的解，从中选择最优
"""
def repeated_nn_tsp(cities):
    return shortest_tour(nn_tsp(cities, start)
                         for start in cities)


def nn_tsp(cities, start=None):
    if start is None:
        start = first(cities)

    tour = [start]
    unvisited = set(cities - {start})
    while unvisited:
        C = nearest_neighbor(tour[-1], unvisited)
        tour.append(C)
        unvisited.remove(C)
    return tour

"""
    比较nn_tsp与repeat_nn_tsp
    plot_tsp(nn_tsp, cities(100))
    plot_tsp(repeated_nn_tsp, cities(100))
    100 city tour with length 6734.1 in 0.004 secs for nn_tsp
    100 city tour with length 5912.6 in 0.485 secs for repeated_nn_tsp
    显然repeat_nn_tsp比nn_tsp表现的更好，但是，如果当城市的个数n很大时，我们就要重复n次，
    有木有一种方法能够改进这种repeat的方式————只是穷尽部分而不是全部的城市
"""
def repeated_nn_tsp(cities, repetitions=100):
    return shortest_tour(nn_tsp(cities, start)
                         for start in sample(cities, repetitions))

def sample(population, k, seed=42):
    """
    从population中选择k个元素作为一个样本
    :param population:
    :param k:
    :param seed:
    :return:
    """
    if k is None or k > len(population):
        return population
    random.seed(len(population) * k * seed)
    return random.sample(population, k)

"""
"""
def Maps(num_maps, num_cities):
    """

    :param num_maps:
    :param num_cities:
    :return:
    """
    return tuple(cities(num_cities, seed=(m, num_cities))
                 for m in range(num_maps))

"""

"""
def memoize(func):
    """
    缓存结果
    :param func:
    :return:
    """
    cache = {}
    def new_func(*args):
        try:
            # 判断，如果之前已经运算过该函数，则返回之前的值
            return cache[args]
        except TypeError:
            # 如果args无法hash，则计算该函数并返回值
            return func(*args)
        except KeyError:
            # 如果args可哈希，计算该函数并存储
            cache[args] = func(*args)
            return cache[args]
    new_func._cache = cache
    new_func.__doc__ = func.__doc__
    new_func.__name__ = func.__name__
    return new_func



@memoize
def benchmark(function, inputs):
    """
    在所有的input上运行， 返回（平均时耗，结果）
    :param function:
    :param inputs:
    :return:
    """
    t0 = time.clock()
    results = list(map(function, inputs))
    t1 = time.clock()
    average_time = (t1 - t0) / len(inputs)
    return (average_time, results)

def benchmarks(tsp_algorithms, maps=Maps(30,60)):
    """
    同时计算多种算法
    :param tsp_algorithms:
    :param maps:
    :return:
    """
    for tsp in tsp_algorithms:
        time, results = benchmark(tsp, maps)
        lengths = map(tour_length, results)
        print("{:>25} |{:7.1f} ± {:4.0f} ({:5.0f} to {:5.0f}) |{:7.3f} secs/map | {}   {}-city maps"
              .format(tsp.__name__, mean(lengths), stddev(lengths), min(lengths), max(lengths),
                      time, len(maps), len(maps[0])))

def mean(numbers):
    return sum(numbers) / len(numbers)

def stddev(numbers):
    """
    标准差
    :param numbers:
    :return:
    """
    return (mean([x ** 2 for x in numbers]) - mean(numbers) ** 2) ** 0.5

"""
    当城市的数量为多少时，nn_tsp能取得最好的效果
"""
def repeat_10_nn_tsp(cities):return repeated_nn_tsp(cities, 10)
def repeat_25_nn_tsp(cities):return repeated_nn_tsp(cities, 25)
def repeat_50_nn_tsp(cities):return repeated_nn_tsp(cities, 50)
def repeat_100_nn_tsp(cities):return repeated_nn_tsp(cities, 100)

algorithms = [nn_tsp, repeat_10_nn_tsp, repeat_25_nn_tsp, repeat_25_nn_tsp,
              repeat_50_nn_tsp, repeat_100_nn_tsp]
print(benchmarks(algorithms))

"""
    最近邻面临的问题：离群点
"""
outliers_list = [City(2, 2),  City(2, 3),  City(2, 4),  City(2, 5),  City(2, 6),
                 City(3, 6),  City(4, 6),  City(5, 6),  City(6, 6),
                 City(6, 5),  City(6, 4),  City(6, 3),  City(6, 2),
                 City(5, 2),  City(4, 2),  City(3, 2),
                 City(1, 6.8),  City(7.8, 6.4),  City(7, 1.2),  City(0.2, 2.8)]

outliers = set(outliers_list)

plot_lines(outliers, 'bo')

 

　　

 plot_tsp(nn_tsp, outliers) 

"""
    存在四个围绕的离群点，但是我们却让它们各自连接————使用了最长的四条线
    —————这不科学
"""
def plot_labeled_lines(points, *args):
    """
    分别画出每个点并标记
    :param points:
    :param args:
    :return:
    """
    plot_lines(points, 'bo')
    for (label, p) in enumerate(points):
        plt.text(X(p), Y(p), ' '+str(label))

        style = 'bo-'
        for arg in args:
            if isinstance(arg, str):
                style = arg
            else:# arg 是points序列链
                Xs = [X(points[i]) for i in arg]
                Ys = [Y(points[i]) for i in arg]
                plt.plot(Xs, Ys, style)
    plt.axis('scaled')
    plt.axis('off')
    plt.show()
"""
　　注意到在第四个点时
"""
plot_labeled_lines(outliers_list, 'bo-', [0, 1, 2, 3, 4], 'ro--', [4, 16], 'bo--', [4, 5])

 

　　

"""
　　此时若是选择离群点所得到的结果更优，
　　在没有模糊的环境下，很难决定是否选择离群点还是义无反顾的选择最近邻
　　建议在构建路径的过程中不要总是想着去做决定，不妨等到路径建设完全后再来考虑离群点
"""