2020_8_27每日一题 重新安排行程

给定一个机票的字符串二维数组 [from, to]，子数组中的两个成员分别表示飞机出发和降落的机场地点，对该行程进行重新规划排序。所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。

说明:

如果存在多种有效的行程，你可以按字符自然排序返回最小的行程组合。例如，行程 [“JFK”, “LGA”] 与 [“JFK”, “LGB”] 相比就更小，排序更靠前
所有的机场都用三个大写字母表示（机场代码）。
假定所有机票至少存在一种合理的行程。
示例 1:

输入: [[“MUC”, “LHR”], [“JFK”, “MUC”], [“SFO”, “SJC”], [“LHR”, “SFO”]]
输出: [“JFK”, “MUC”, “LHR”, “SFO”, “SJC”]
示例 2:

输入: [[“JFK”,“SFO”],[“JFK”,“ATL”],[“SFO”,“ATL”],[“ATL”,“JFK”],[“ATL”,“SFO”]]
输出: [“JFK”,“ATL”,“JFK”,“SFO”,“ATL”,“SFO”]
解释: 另一种有效的行程是 [“JFK”,“SFO”,“ATL”,“JFK”,“ATL”,“SFO”]。但是它自然排序更大更靠后。

猛一看就是个图论的题，仔细一看是一个一笔画问题。由于前两天题目的影响，直接就考虑回溯算法。尝试走一条路如果不行后退，选择下一条路。对于要求字典序的路径优先，可以在寻找的时候优先字母小的目的地。这里就涉及到图的数据结构的选择。由于再往前寻找的过程中要求删除已经经过的节点，并在没有希望的时候加回来，因此要求能够快速的增删；此外，再考察某一个节点时，应能够快速地排序。最后选择了实现一个multiset来满足这些要求：

class Solution {
    int expect;

    private void addTicket(TreeMap<String, Integer> tree, String to) {

        if(tree.containsKey(to)) {
            tree.put(to, tree.get(to) + 1);
        } else {
            tree.put(to, 1);
        }
    }

    private void delTicket(TreeMap<String, Integer> tree, String to) {
        int num = tree.get(to);
        if(num == 1) {
            tree.remove(to);
        } else {
            tree.put(to, num - 1);
        }
    }

    private boolean rec(LinkedList<String>  ans, HashMap<String, TreeMap<String, Integer>> graph, String cur) {
        //由于递归中会更改tree 所以先把当前时刻剩的所有票n拿出来迭代
        TreeMap<String, Integer> tree = graph.get(cur);
        ans.add(cur);
        if(tree == null || tree.size() == 0 ) {
            if(ans.size() == expect) {
                return true;
            } else {
                ans.removeLast();
                return false;
            }            
        }
        String[] curTickets = tree.keySet().toArray(new String[0]);
        

        for(String to : curTickets) {
            delTicket(tree, to);
            if(rec(ans, graph, to) == true) {
                return true;
            }
                
            addTicket(tree, to);
        }
        ans.removeLast();
        return false;
    }

    public List<String> findItinerary(List<List<String>> tickets) {
        LinkedList<String> ans = new LinkedList<String>();
        expect = tickets.size() + 1;
        HashMap<String, TreeMap<String, Integer>> graph = new HashMap<String, TreeMap<String, Integer>>();
        //依然是回溯算法 这次不用全局变量试一试
        for(List<String> ticket : tickets) {
            TreeMap<String, Integer> tree;
            String from = ticket.get(0);
            String to = ticket.get(1);
            if(graph.containsKey(from)) {
                tree = graph.get(from);
            } else {
                tree = new TreeMap<String, Integer>();
                graph.put(from, tree);
            }
            addTicket(tree, to);
        }

        rec(ans, graph, "JFK");

        return ans;
    }
}

看了一下题解，使用dfs能非常漂亮地解决这个问题。代码如下：

class Solution {

    void rec(LinkedList<String> ans, HashMap<String, PriorityQueue<String>> graph, String cur) {
        while(graph.containsKey(cur) && graph.get(cur).size() != 0) {
            rec(ans, graph, graph.get(cur).poll());
        }

        ans.addFirst(cur);
    }

    public List<String> findItinerary(List<List<String>> tickets) {
        LinkedList<String> ans = new LinkedList<String>();
        HashMap<String, PriorityQueue<String>> graph = new HashMap<String, PriorityQueue<String>>();
        for(List<String> ticket : tickets) {
            PriorityQueue<String> q;
            String from = ticket.get(0);
            String to = ticket.get(1);
            if(graph.containsKey(from)) {
                q = graph.get(from);
            } else {
                q = new PriorityQueue<String>();
                graph.put(from, q);
            }
            q.add(to);
        }

        rec(ans, graph, "JFK");

        return ans;
    }
}

代码很简单。思路是先贪心地往前找，知道没有路走了返回。如果走到死胡同了退回。要点是在dfs返回的时候更新答案，由于题目中的图满足可以找到一笔画，只有一个死胡同，可以保证死胡同是最早返回的，按照倒序往答案里添加，则可以保证是最后走到死胡同的。
说起来很简单代码实现也不难，但是智力孤危的我实在是想不明白这么做为什么是正确的TAT。闷头想了半天，把一些思考的结果分享一下吧。
假设走到死胡同的时候的路径是s1。那么dfs返回的时候，如果存在别的分支，相当于往s1上添加子路。不妨设存在子路为s2，如果s2能够插入到s1的不同的位置，由于s1是贪心的方式选出的所以s1中节点的相对位置肯定是当前为最优。以一个例子说明：

一开始走到死胡同的路是DABCDB，可行的路包括DABCECDB和DBCECDA。则按章一开始贪心的方法选出的路径字典序最优

此外，分支能加在不同位置，同样由于一开始走到死胡同的是贪心选出的，应当是加在靠后的位置字典序更优。例子：

贪心的走的死胡同是ABCBC则BDB分支放在靠近结尾的地方比较好。二者正是DFS能够保证的

其实这么个解释法不是特别数学…可惜我的智力就这水平了