What’s actually big

The biggest clusters each sit between 200 and 300 papers. Grouped roughly:

Language

• RLHF and preference alignment
• LLM agents and code generation
• LLM reasoning, math, chain-of-thought
• In-context learning, induction heads
• LoRA and parameter-efficient fine-tuning

Vision

• Video understanding and temporal grounding
• Human motion and hand interaction
• Text-to-image generation
• 3D Gaussian splatting
• Diffusion sampling, consistency models, flow matching

Methods, RL, theory

• Continual / class-incremental learning
• Linear attention and state-space models (Mamba etc.)
• Federated learning
• World models and goal-conditioned RL
• Multi-agent RL, offline RL
• Differential privacy, membership inference attacks
• Conformal prediction, spiking neural networks
• Molecular ML and drug discovery

Crowded but a step down: time-series forecasting, point cloud segmentation, LiDAR/radar detection, pruning and sparsity. There’s also a surprisingly fat cluster around grokking, two-layer networks, and Kolmogorov-Arnold things, which I read as the small-theory subfield being healthier than people give it credit for.

Where almost nobody is

Tiny clusters, 7-10 papers each, the kind of niche where you can read everything in a weekend:

• Text-to-SQL
• Event-based vision and depth
• Face restoration and rigging
• Protein conformational dynamics
• Link prediction
• DNA regulatory sequence design
• Counterfactual generation
• Self-supervised equivariance

A few subfields barely register at these four venues. Event cameras and DNA sequence design are good examples. Either the community is publishing at specialized venues (NeurIPS Datasets & Benchmarks, MICCAI, ISMB, CVPR workshops), or there genuinely isn’t enough work to fill a session.

How I’d use it

• If you’re about to claim your idea is new, look up where it would land on the map and read the closest five papers first. Cheaper than finding out during rebuttal.
• If you’re picking a PhD topic, look for small islands sitting next to a big cluster. That’s usually a gap with a path back to the mainline.
• If you’re reviewing, the map is a fast sanity check on the “underexplored” framing in someone’s introduction.

Caveats

Embedding clusters reflect title and abstract wording. Two papers can sit in the same cluster and be doing completely different things, just because they share buzzwords. Two papers can sit far apart and be closer in practice than the map suggests. Use this as a starting point, not as a literature review.

Missing on purpose: workshops, datasets-and-benchmarks tracks, ACL, EMNLP, MICCAI, ISBI. Medical imaging venues are next on my list.

If your cluster looks wrong or you spot a paper that’s clearly mislabeled, ping me on GitHub. I’ll rerun it.

Christofides (the 1.5-approximation)

Christofides only works on metric TSP instances: distances must be symmetric and obey the triangle inequality. In return it gives you a tour guaranteed to be at most 1.5× the optimal length. It is still the best constant-factor approximation known for metric TSP that doesn’t depend on exotic results.

The recipe:

1. Build a minimum spanning tree T of the graph.
2. Find the set O of vertices with odd degree in T.
3. Compute a minimum-weight perfect matching M on O.
4. Combine T ∪ M into a multigraph. Every vertex now has even degree.
5. Find an Eulerian circuit.
6. Shortcut repeated vertices (use the triangle inequality to make a Hamiltonian cycle out of it).

The trickiest step is the matching. networkx ships max_weight_matching, which finds a maximum-weight matching, so to get the minimum one I flip the sign of the weights. That only works because the algorithm doesn’t drop edges with negative weights when you ask for maximum cardinality. Subtracting weights from a large constant is the cleaner trick if you want positive numbers.

For Euler circuits and MSTs, just use networkx. No need to reinvent.

# pseudo-summary; full code in pytsp/christofides.py
mst   = prim(graph)
odd   = [v for v in mst if mst.degree(v) % 2]
match = min_weight_perfect_matching(graph, odd)
H     = nx.MultiGraph(mst); H.add_edges_from(match)
tour  = list(nx.eulerian_circuit(H))
tour  = shortcut(tour)  # remove repeats

2-opt (the workhorse)

2-opt is the simplest local-search heuristic for TSP. Start with any tour. Repeatedly: pick two non-adjacent edges, delete them, and reconnect the two resulting paths the other way. Keep the change if the new tour is shorter.

... → A — B ... C — D → ...        (original)
... → A — C ... B — D → ...        (after a 2-opt swap)

The middle segment between B and C gets reversed. The move costs O(1) to evaluate (d(A,C) + d(B,D) − d(A,B) − d(C,D)), and a full pass over all candidate pairs is O(n²). The algorithm terminates at a local minimum where no swap improves the tour.

In practice 2-opt converges fast and gets within a few percent of the optimum on Euclidean instances. It’s the default starting point for any TSP code.

3-opt (the bigger hammer)

3-opt removes three edges instead of two, breaking the tour into three segments A, B, C. There are 8 ways to reconnect them (including the original), of which 4 are real 3-opt moves and 3 are equivalent to 2-opt moves. So you really only have 4 new moves to consider.

The cost-change function compares each reconnection’s total edge weight against the original. Whichever case wins, you splice the segments back in the right order (with some reversed). The cost per move is still O(1) to evaluate; the bottleneck is the O(n³) iteration over edge triples.

A small implementation sketch:

for i, j, k in triples(route):
    best_case, best_gain = argmin_cases(graph, route, i, j, k)
    if best_gain < 0:
        route = apply_case(route, i, j, k, best_case)

3-opt finds better local optima than 2-opt, at the cost of n times more work per iteration. Use it when 2-opt is stuck and you can afford the runtime.

What to use when

• Small symmetric metric instances, want a guarantee: Christofides.
• Any instance, fast and good enough: 2-opt from a greedy or random start.
• Squeezing the last few percent: 3-opt, or move to LKH / Concorde for serious work.

Full implementations are on GitHub: BraveDistribution/pytsp. PRs welcome. The code is years old at this point and could use a Kruskal implementation, better tests, and a benchmark script.

References

• Christofides, N. Worst-case analysis of a new heuristic for the travelling salesman problem. CMU Tech Report (1976).
• Lin, S.; Kernighan, B. An Effective Heuristic Algorithm for the Traveling-Salesman Problem. Operations Research 21(2), 1973.
• Helsgaun, K. An effective implementation of the Lin–Kernighan traveling salesman heuristic. EJOR 126(1), 2000.
• TSP basics blog: https://tsp-basics.blogspot.com/