dost

@@ -61,60 +61,31 @@ def show_mat(distances: DistTable) -> str:

         rows.append(row)

     return "\n".join(rows)

-# promising

-def score_nearest(distances: DistTable, sample: IndSeq) -> float:

-    return sum(0 if i in sample else min(distances[i][j] for j in sample) for i in range(len(distances)))

-

-# too centred and slow

-def score_total(distances: DistTable, sample: IndSeq) -> float:

-    return sum(sum(

-        0 if i in sample else distances[i][j] for j in sample

-    ) for i in range(len(distances)))

-

-# promising, needs revision

-def score_spread(distances: DistTable, sample: IndSeq) -> float:

-    return -sum(sum(distances[sample[i]][j] for j in sample[:i]) for i in range(len(sample)))

-

-def score_sqrt_spread(distances: DistTable, sample: IndSeq) -> float:

-    return -sum(sum(

-        math.sqrt(distances[sample[i]][j]) for j in sample[:i]

-    ) for i in range(len(sample)))

-

-def greedy_min_seq(distances: DistTable, score_func: Func[[DistTable, IndSeq], float]) -> IndSeq:

-    seq = []

-    options = set(range(len(distances)))

-    while options:

-        best = min(options, key=lambda o: score_func(distances, seq + [o]))

-        seq.append(best)

-        options.remove(best)

-    return seq

-

-def score_maximin(distances: DistTable, sample: IndSeq) -> float:

-    return min(min(distances[sample[i]][j] for j in sample[:i]) for i in range(1, len(sample)))

-

-# promising

-def greedy_maximin(distances: DistTable) -> IndSeq:

+# good results, slow

+def cachey_nearest(distances: DistTable) -> IndSeq:

     seq = []

     options = set(range(len(distances)))

-    start = min(options, key=lambda o: score_nearest(distances, [o]))

-    seq.append(start)

-    options.remove(start)

+    nearests = [math.inf for _ in range(len(distances))]

     while options:

-        best = max(options, key=lambda o: score_maximin(distances, seq + [o]))

+        reduceds = {o: [min(distances[o][i], nearests[i]) for i in range(len(nearests))] for o in options}

+        best = min(options, key=lambda o: sum(reduceds[o]))

+        nearests = reduceds[best]

         seq.append(best)

         options.remove(best)

     return seq

-# too edge-clustery

-def furthest_nb(distances: DistTable) -> IndSeq:

+# good results, sketchy on a couple trials

+def cachey_maximin(distances: DistTable) -> IndSeq:

     seq = []

     options = set(range(len(distances)))

-    start = min(options, key=lambda o: score_nearest(distances, [o]))

+    start = min(options, key=lambda o: sum(distances[o]))

     seq.append(start)

     options.remove(start)

+    score = math.inf

     while options:

-        dl = distances[seq[-1]]

-        best = max(options, key=lambda o: dl[o])

+        updateds = {o: min(min(distances[o][i] for i in seq), score) for o in options}

+        best = max(options, key=lambda o: updateds[o])

+        score = updateds[best]

         seq.append(best)

         options.remove(best)

     return seq

@@ -130,7 +101,7 @@ def distance_hierarchy(distances: DistTable) -> BinaryTree:

         p = forest[i].merge(forest[j])

     return p

-# promising

+# good results, sketchy on somewhat more trials

 def scattered_hierarchy(hierarchy: BinaryTree) -> IndSeq:

     seq = []

     while hierarchy.usage < hierarchy.weight:

@@ -152,8 +123,10 @@ def total_len(distances: DistTable, seq: IndSeq) -> float:

     return sum(distances[i][j] for (i, j) in itertools.pairwise(seq))

 points: list[str] = [l.strip() for l in sys.stdin]

+to = time.time()

 dt: DistTable = distance_table(points, lambda a, b: Levenshtein.distance(a, b, weights=(1, 1, 3)))

-print(show_mat(dt))

+tf = time.time()

+print(f"took {tf - to} s to calculate distances")

 to = time.time()

 h: BinaryTree = distance_hierarchy(dt)

 tf = time.time()

@@ -161,8 +134,8 @@ print(f"took {tf - to} s to build hierarchy")

 print(h)

 METHODS = [

     ("graph", lambda: scattered_hierarchy(h)),

-    ("nearest-nb sum", lambda: greedy_min_seq(dt, score_nearest)),

-    ("maximin", lambda: greedy_maximin(dt)),

+    ("nearest-nb", lambda: cachey_nearest(dt)),

+    ("maximin", lambda: cachey_maximin(dt)),

 ]

 for (name, method) in METHODS:

     to = time.time()