一筆書き (ヒアホルツァー法) で全部の切符を使う旅程を組み立てる

def itinerary(tickets, start):
    # 行き先を辞書の逆の順に持つ
    nxt = {}
    order = sorted(tickets)
    for a, b in reversed(order):
        nxt.setdefault(a, [])
        nxt[a].append(b)
    route = []
    stack = [start]
    while stack:
        top = stack[-1]
        if nxt.get(top):
            b = nxt[top].pop()
            stack.append(b)
        else:
            stack.pop()
            route.append(top)
    return route[::-1]

function itinerary(
  tickets, start,
) {
  // 空港は 3 字なので、2 つを
  // つなげた字の順で並べられる
  const keys = tickets.map(
    ([a, b]) => a + b);
  // 辞書の逆の順にする
  keys.sort().reverse();
  const nxt = new Map();
  for (const k of keys) {
    const a = k.slice(0, 3);
    if (!nxt.has(a)) {
      nxt.set(a, []);
    }
    nxt.get(a).push(k.slice(3));
  }
  const route = [];
  const stack = [start];
  while (stack.length) {
    const top = stack.at(-1);
    const out = nxt.get(top);
    if (out?.length) {
      stack.push(out.pop());
    } else {
      route.push(stack.pop());
    }
  }
  return route.reverse();
}

import (
	"slices"
	"sort"
)

func itinerary(
	tickets [][]string,
	start string,
) []string {
	// 行き先を辞書の逆の順に持つ
	t := append(
		[][]string{}, tickets...)
	sort.Slice(t, func(
		i, j int,
	) bool {
		if t[i][0] != t[j][0] {
			return t[i][0] > t[j][0]
		}
		return t[i][1] > t[j][1]
	})
	nxt := map[string][]string{}
	for _, e := range t {
		nxt[e[0]] = append(
			nxt[e[0]], e[1])
	}
	route := []string{}
	stack := []string{start}
	for len(stack) > 0 {
		top := stack[len(stack)-1]
		out := nxt[top]
		n := len(out) - 1
		if n >= 0 {
			nxt[top] = out[:n]
			stack = append(
				stack, out[n])
			continue
		}
		stack = stack[:len(stack)-1]
		route = append(route, top)
	}
	slices.Reverse(route)
	return route
}