leetcode:332. Reconstruct Itinerary

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:

1. 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"].
2. All airports are represented by three capital letters (IATA code).
3. You may assume all tickets form at least one valid itinerary.

Example 1:
tickets = [["MUC", "LHR"], ["JFK", "MUC"], ["SFO", "SJC"], ["LHR", "SFO"]]
Return ["JFK", "MUC", "LHR", "SFO", "SJC"].

Example 2:
tickets = [["JFK","SFO"],["JFK","ATL"],["SFO","ATL"],["ATL","JFK"],["ATL","SFO"]]
Return ["JFK","ATL","JFK","SFO","ATL","SFO"].

Another possible reconstruction is ["JFK","SFO","ATL","JFK","ATL","SFO"]. But it is larger in lexical order.

题意&解题思路

给一堆飞机票，把所有机票按最小字典序连起来输出（必须用上所有tickets，并且第一张一定为"JFK"）。将机票对作为有向图的边建图，再对各点邻接表连接的目的地按字典序排个序。然后用深搜从"JFK"开始对图进行搜索，目的地从小到大搜。当搜到第一条用上所有机票的路径，就直接返回，不再往下搜索。

class Solution {
public:
    struct node{
        string str;
        int vis;
    };
    static bool myCompare(const node& v1, const node& v2){
        return v1.str < v2.str;
    }
    int flag;
    vector<string>ans;
    map<string, int>ha;
    void dfs(int cur, int step, int ansLen, vector<node>* linkList){
        if(flag)return;
        if(step == ansLen){
            flag = 1;
            return;
        }
        
        for(int i = 0; i < linkList[cur].size(); i++){
            if(!linkList[cur][i].vis){
                linkList[cur][i].vis = 1;
                ans.push_back(linkList[cur][i].str);
                dfs(ha[linkList[cur][i].str], step + 1, ansLen, linkList);
                if(flag)return;
                ans.pop_back();
                linkList[cur][i].vis = 0;
            }
        }
    }
    vector<string> findItinerary(vector<pair<string, string>> tickets) {
        
        int ansLen = tickets.size();
        
        vector<node>linkList[ansLen + 2];
        int ind = 1;
        for(int i = 0; i < ansLen; i++){
            string head = tickets[i].first;
            string next = tickets[i].second;
            if(!ha[head])ha[head] = ind++;
            if(!ha[next])ha[next] = ind++;
            node tmp;
            tmp.str = next;
            tmp.vis = 0;
            linkList[ha[head]].push_back(tmp);
        }
        
        for(int i = 1; i < ind; i++){
            sort(linkList[i].begin(), linkList[i].end(), myCompare);
        }
        flag = 0;
        int st = ha["JFK"];
        ans.push_back("JFK");
        dfs(st, 0, ansLen, linkList);
        
        return ans;
    }
};