LeetCode 332. Reconstruct Itinerary（dfs）

332. Reconstruct Itinerary

Medium

Given a list of airline tickets represented by pairs of departure and arrival airports [from, to], reconstruct the itinerary in order. All of the tickets belong to a man who departs from JFK. Thus, the itinerary must begin with JFK.

Note:

If there are multiple valid itineraries, you should return the itinerary that has the smallest lexical order when read as a single string. For example, the itinerary [“JFK”, “LGA”] has a smaller lexical order than [“JFK”, “LGB”].
All airports are represented by three capital letters (IATA code).
You may assume all tickets form at least one valid itinerary.
Example 1:

Input: [[“MUC”, “LHR”], [“JFK”, “MUC”], [“SFO”, “SJC”], [“LHR”, “SFO”]]
Output: [“JFK”, “MUC”, “LHR”, “SFO”, “SJC”]
Example 2:

Input: [[“JFK”,“SFO”],[“JFK”,“ATL”],[“SFO”,“ATL”],[“ATL”,“JFK”],[“ATL”,“SFO”]]
Output: [“JFK”,“ATL”,“JFK”,“SFO”,“ATL”,“SFO”]
Explanation: Another possible reconstruction is [“JFK”,“SFO”,“ATL”,“JFK”,“ATL”,“SFO”].
But it is larger in lexical order.

题意

求字典序最小的欧拉道路（一笔画问题）

思路

dfs + 倒序输出。详解见LeetCode中文网的一份超详细的Java题解

代码

class Solution {
    private void dfs(String src, Map<String, LinkedList<String>> adj, List<String> ans) {
        // System.out.println(src);
        if (!adj.containsKey(src) || adj.get(src) == null || adj.get(src).size() == 0) {
            ans.add(src);
            return;
        }
        while (!adj.get(src).isEmpty()) {
            String dst = adj.get(src).removeFirst();
            dfs(dst, adj, ans);
        }
        ans.add(src);
    }
    
    public List<String> findItinerary(List<List<String>> tickets) {
        List<String> ans = new ArrayList<String>();
        if (tickets.size() == 0) {
            ans.add("JFK");
            return ans;
        }
        Map<String, LinkedList<String>> adj = new HashMap<String, LinkedList<String>>();
        for (List<String> edge: tickets) {
            if (adj.containsKey(edge.get(0))) {
                adj.get(edge.get(0)).add(edge.get(1));
            } else {
                adj.put(edge.get(0), new LinkedList<String>() {
                    {
                        add(edge.get(1));
                    }
                });
            }
        }
        for (List<String> tos: adj.values()) {
            Collections.sort(tos);
        }
        dfs("JFK", adj, ans);
        Collections.reverse(ans);
        return ans;
    }
}