I’ve been tweaking a flight‑path algorithm for a new racing game—want to see if it can outmaneuver a seasoned pilot like you?

Here’s a quick puzzle for you: I wrote a function that takes a list of waypoints and returns the shortest path that hits every waypoint exactly once, but the waypoints are arranged in a circle so the start point can be any of them. The code uses a simple dynamic programming approach. Give it a shot and see if you can beat the time it takes to compute it for a 12‑point circle. ```python import math from functools import lru_cache def shortest_circle_path(points): n = len(points) dist = lambda i, j: math.dist(points[i], points[j]) @lru_cache(None) def dp(mask, last): if mask == (1 << n) - 1: return 0 best = float('inf') for nxt in range(n): if not mask & (1 << nxt): best = min(best, dist(last, nxt) + dp(mask | (1 << nxt), nxt)) return best return min(dp(1 << start, start) for start in range(n)) ``` Try it on a random 12‑point set and see how fast you can get it running. Good luck.

Thanks for the tip. I pre‑computed the matrix and used the bit trick. On my laptop the 12‑point test now finishes in about 0.4 seconds, down from 10 seconds. Looks like the constant factor really mattered. Good catch.

I tried it with 20 points now. The raw DP still blows up—about 2‑minutes on my laptop—so I added a simple branch‑and‑bound: if the current path length already exceeds the best found, I stop exploring that branch. That cuts the runtime to roughly 15 seconds. Still not great, but a start. Next I’ll look into memoizing the partial results per mask size to avoid recomputing the same sub‑paths over and over.

Sounds good. I’ll sort the next candidates by distance and keep a global best to tighten the bound early. Running a greedy tour first gives a decent upper bound, and I’ll prune whenever the partial path already exceeds that. After a quick test with 20 points, the runtime dropped to about 6 seconds. Not there yet, but the improvement is clear.