332重新安排行程（递归回溯dfs深度优先搜索）

最新推荐文章于 2023-01-19 22:55:18 发布

Revendell

最新推荐文章于 2023-01-19 22:55:18 发布

阅读量135

点赞数

分类专栏： LeetCode 文章标签： leetcode 算法

本文链接：https://blog.csdn.net/Revendell/article/details/112061177

版权

LeetCode 专栏收录该内容

368 篇文章 20 订阅

订阅专栏

1、题目描述

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

提示：

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

2、示例

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

3、题解

基本思想：递归回溯dfs深度优先搜索，使用map<string,map<string,int>>数据结构保存图，因为map是二叉平衡树，所以是有序的。

因为有向图从JFK出发遍历每个节点的路径是存在的，并且返回字典序最小的路径，所以从JFK出发按字典序遍历JFK指向的每个节点，遍历某个节点后，计数减1
如果最后路径走过的边数为edges，这一路径就是最终返回的结果，否则返回false说明此路径并不能走通，节点pop
一开始使用map<string,multiset<string>>保存图，但是某条边走过就需要erase，这样函数参数多了vexNode，导致效率及其低下

#include<iostream>
#include<vector>
#include<algorithm>
#include<map>
#include<set>
#include<string>
using namespace std;
class Solution {
public:
    vector<string> res;
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        map<string,multiset<string>> vexNode;
        for(int i=0;i<tickets.size();i++)
            vexNode[tickets[i].front()].insert(tickets[i].back());
        int edges=tickets.size();
        dfs("JFK",edges,vexNode);
        return res;
    }
    bool dfs(string cur,int edges,map<string,multiset<string>> vexNode)
    {
        res.push_back(cur);
        if(edges==0)
            return true;
        for(auto iter=vexNode[cur].begin();iter!=vexNode[cur].end();iter++)
        {
            map<string,multiset<string>> temp(vexNode);
            auto iterera=temp[cur].find(*iter);
            temp[cur].erase(iterera);
            if(dfs(*iter,edges-1,temp))
                return true;
            res.pop_back();
        }
        return false;
    }
};
class Solution1 {
public:
    vector<string> res;
    map<string,map<string,int>> vexNode;
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        //基本思想：递归回溯dfs深度优先搜索，使用map<string,map<string,int>>数据结构保存图，因为map是二叉平衡树，所以是有序的
        //因为有向图从JFK出发遍历每个节点的路径是存在的，并且返回字典序最小的路径，所以从JFK出发按字典序遍历JFK指向的每个节点
        //如果最后路径走过的边数为edges，这一路径就是最终返回的结果，否则返回false说明此路径并不能走通，节点pop
        //一开始使用map<string,multiset<string>>保存图，但是某条边走过就需要erase，这样函数参数多了vexNode，导致效率及其低下
        for(int i=0;i<tickets.size();i++)
            vexNode[tickets[i].front()][tickets[i].back()]++;
        int edges=tickets.size();
        dfs("JFK",edges);
        return res;
    }
    bool dfs(string cur,int edges)
    {
        res.push_back(cur);
        if(edges==0)
            return true;
        for(auto iter=vexNode[cur].begin();iter!=vexNode[cur].end();iter++)
        {
            if(iter->second>0)
            {
                iter->second--;
                if(dfs(iter->first,edges-1))
                    return true;
                iter->second++;
                res.pop_back();
            }
        }
        return false;
    }
};
int main()
{
    Solution1 solute;
    vector<vector<string>> tickets={{"JFK","SFO"},{"JFK","ATL"},{"SFO","ATL"},{"ATL","JFK"},{"ATL","SFO"}};
    vector<string> res=solute.findItinerary(tickets);
    for_each(res.begin(),res.end(),[](const string &v){cout<<v<<endl;});
    return 0;
}