代码随想录——回溯19重新安排行程

合集 - 代码随想录(35)

16.代码随想录——回溯19重新安排行程2024-12-12

思路

回溯——超时代码

把选机票当成走迷宫问题，选择一次机票就进入下一个地点，然后标记此次路径已使用。直接使用回溯模板。

    vector<string> result;
    vector<string> path;
    void backTracking(vector<vector<string>>& tickets,vector<bool>& used,int k){
        if(k == tickets.size()){//所有机票都用过了
            if(result.size()==0 || Compare(path,result)){
                result=path;//如果现在的字典排序更小，就更换
            }
            return;
        }
        string cur;//现在在哪里
        if(path.size()==0){
            cur = "JFK";
            path.emplace_back("JFK");
        }
        for(int i=0;i<tickets.size();i++){
            cur = path[path.size()-1];
            if(tickets[i][0] == cur){//机票满足cur->xx
                if(used[i]== false){//机票还没用过
                    path.emplace_back(tickets[i][1]);//填入目的地
                    used[i] = true;//标记机票已使用
                    backTracking(tickets,used,k+1);
                    used[i]= false;//回溯，取消标记+目的地
                    path.pop_back();
                }
            }
        }
    }
    bool Compare(vector<string>& path,vector<string>& result){
        for(int i =0;i<path.size();i++){
            string a = path[i];
            string b = result[i];
            if(a < b)return true;
            else if( a > b)return false;
        }
        return false;
    }
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        //所有的机票 必须都用一次 且 只能用一次 —— 回溯走迷宫
        //只返回字典序最小的组合
        vector<bool> used(tickets.size());
        backTracking(tickets,used,0);
        return result;
    }

正确的回溯(深搜)代码

错误代码问题显而易见：

需要把所有行程找到，并且手动比较字典序
每次需要把所有机票遍历一次，没有使用数据结构进行优化

优化：

排序 + DFS

在进行回溯前，按照起点和终点对机票列表进行排序，这样字典序较小的路径会优先被探索，从而无需手动比较路径字典序，减少 Compare 的计算开销。
因为路径是按字典序构造的，第一个合法结果就是字典序最小的。DFS在找到第一个合法解后立即返回，避免无意义的继续搜索。

邻接表优化搜索空间

使用邻接表存储机票信息，并排序邻接表中的目的地，这样每次可以直接访问与当前地点相关的机票，减少不必要的遍历。
具体而言：邻接表即一对多的映射，可以使用std::unordered_map；排序字符串就是用std::map 或者std::multimap 或者 std::multiset。

这样存放映射关系可以定义为 unordered_map<string, multiset> targets 或者 unordered_map<string,map<string, int>> targets。

含义如下：

unordered_map<string, multiset> targets：unordered_map<出发机场, 到达机场的集合> targets

unordered_map<string, map<string, int>> targets：unordered_map<出发机场, map<到达机场, 航班次数>> targets

这里我选择后者，因为后者可以"航班次数"这个字段的数字做相应的增减标记机票是否使用过

    vector<string> result;
    unordered_map<string,map<string,int>> targets;//unordered_map<起始机场，map<到达机场，航班次数>> 次数0或1，标记是否用过该机票

    bool backTracking(int targetNum,string cur){//因为机票按字典序排序，所以找到有效行程时就是最小字典序，直接返回
        if(result.size() == targetNum + 1){
            return true;
        }
        for(pair<const string,int>& target : targets[cur]){
            if(target.second > 0){
                target.second--;
                result.emplace_back(target.first);
                if(backTracking(targetNum,target.first))return true;//如果找到了就一直return true
                result.pop_back();
                target.second++;
            }
        }
        return false;
    }

    vector<string> findItinerary(vector<vector<string>>& tickets) {
        for(vector<string>& ticket : tickets){
            targets[ticket[0]][ticket[1]]++;
        }
        result.emplace_back("JFK");
        backTracking(tickets.size(),"JFK");
        return result;
    }