leetcode 332. Reconstruct Itinerary

最新推荐文章于 2017-10-15 22:18:42 发布
最新推荐文章于 2017-10-15 22:18:42 发布
阅读量705 收藏
点赞数
分类专栏： 数据结构与算法 OJ 文章标签： leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014568921/article/details/50755501
版权
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:
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.


// ConsoleApplication6.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<string>
#include<vector>
#include<map>
#include<set>
#include<algorithm>
#include<iostream>


using namespace std;

class Solution {
public:
	vector<string> findItinerary(vector<pair<string, string>> tickets) {
		struct compare
		{
			vector<pair<string, string>>vv;
			compare(vector<pair<string, string>>uu){ vv = uu; }
			bool operator()(pair<string, string > ds1, pair<string, string>ds2)
			{
				for (int i = 0; i < 3; i++)
				{
					if (ds1.first[i] - ds2.first[i] < 0)
						return true;
					else if (ds1.first[i] - ds2.first[i] > 0)
						return false;
				}
				for (int i = 0; i < 3; i++)
				{
					if (ds1.second[i] - ds2.second[i] < 0)
						return true;
					else if (ds1.second[i] - ds2.second[i] > 0)
						return false;
				}
				return false;
			}
		};
		std::sort(tickets.begin(), tickets.end(), compare(tickets));
		map<string, set<string>>pp, ppp;
		map<pair<string, string>, int>count, count2;
		for (int i = 0; i < tickets.size(); i++)
		{
			pp[tickets[i].first].insert(tickets[i].second);
			count[tickets[i]]++;
		}
		vector<string>re;
		set<vector<string>>aa;
		for (int i = 0; i < tickets.size(); i++)
		{
			if (i>0 && tickets[i - 1] == tickets[i])
				continue;
			aa.clear();
			re.clear();
			count2 = count;
			ppp = pp;
			re.push_back(tickets[i].first);
			re.push_back(tickets[i].second);
			count2[tickets[i]]--;
			if (count2[tickets[i]] == 0)
				ppp[tickets[i].first].erase(ppp[tickets[i].first].find(tickets[i].second));
			while (true)
			{
				while (ppp[re.back()].size() > 0)
				{
					string str = re.back();
					re.push_back(*ppp[str].begin());
					count2[pair<string, string>(str, re.back())]--;
					if (count2[pair<string, string>(str, re.back())] == 0)
						ppp[str].erase(ppp[str].begin());
					if (re.size() == tickets.size() + 1)
						return re;
				}
				int kk = re.size() - 2;
				bool f = false;
				while (!f&&kk >= 1)
				{
					while (kk >= 1 && ppp[re[kk]].size() == 0)
					{
						kk--;
					}
					if (kk == 0)
						break;
					for (int j = kk; j < re.size() - 1; j++)
					{
						ppp[re[j]].insert(re[j + 1]);
						count2[pair<string, string>(re[j], re[j + 1])]++;
					}
					aa.insert(vector<string>(re.begin(), re.begin() + kk + 2));
					re.erase(re.begin() + kk + 1, re.end());
					for (set<string>::iterator it = ppp[re.back()].begin(); it != ppp[re.back()].end(); it++)
					{
						vector<string>temp = re;
						temp.push_back(*it);
						if (aa.find(temp) == aa.end())
						{
							f = true;
							aa.insert(temp);
							count2[pair<string, string>(re.back(), *it)]--;
							if (count2[pair<string, string>(re.back(), *it)] == 0)
								ppp[re.back()].erase(it);
							re = temp;
							break;
						}
					}
					if (!f)
						kk--;
				}
				if (kk == 0)
					break;
			}
		}
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	Solution sl;
	vector<pair<string, string>>tickets;
	//tickets = [["JFK","SFO"],["JFK","ATL"],["SFO","ATL"],["ATL","JFK"],["ATL","SFO"]]

	/*[["EZE","TIA"],["EZE","HBA"],["AXA","TIA"],["JFK","AXA"],["ANU","JFK"],
	["ADL","ANU"],["TIA","AUA"],["ANU","AUA"],["ADL","EZE"],["ADL","EZE"],
	["EZE","ADL"],["AXA","EZE"],["AUA","AXA"],["JFK","AXA"],["AXA","AUA"],
	["AUA","ADL"],["ANU","EZE"],["TIA","ADL"],["EZE","ANU"],["AUA","ANU"]]*/
	tickets.push_back(pair<string, string>("EZE", "TIA"));
	tickets.push_back(pair<string, string>("EZE", "HBA"));
	tickets.push_back(pair<string, string>("AXA", "TIA"));
	tickets.push_back(pair<string, string>("JFK", "AXA"));
	tickets.push_back(pair<string, string>("ANU", "JFK"));

	tickets.push_back(pair<string, string>("ADL", "ANU"));
	tickets.push_back(pair<string, string>("TIA", "AUA"));
	tickets.push_back(pair<string, string>("ANU", "AUA"));
	tickets.push_back(pair<string, string>("ADL", "EZE"));
	tickets.push_back(pair<string, string>("ADL", "EZE"));

	tickets.push_back(pair<string, string>("EZE", "ADL"));
	tickets.push_back(pair<string, string>("AXA", "EZE"));
	tickets.push_back(pair<string, string>("AUA", "AXA"));
	tickets.push_back(pair<string, string>("JFK", "AXA"));
	tickets.push_back(pair<string, string>("AXA", "AUA"));

	tickets.push_back(pair<string, string>("AUA", "ADL"));
	tickets.push_back(pair<string, string>("ANU", "EZE"));
	tickets.push_back(pair<string, string>("TIA", "ADL"));
	tickets.push_back(pair<string, string>("EZE", "ANU"));
	tickets.push_back(pair<string, string>("AUA", "ANU"));

	vector<string>re = sl.findItinerary(tickets);

	system("pause");
	return 0;
}

妈的，超时

过了大概一个月重新看这道题，发现题意没审清楚，JFK要打头，这就简单很多了嘛。然后修改了下

class Solution {
public:
	vector<string> findItinerary(vector<pair<string, string>> tickets) {
		clock_t start, finish;
		double Total_time;
		start = clock();

		struct compare
		{
			vector<pair<string, string>>vv;
			compare(vector<pair<string, string>>uu){ vv = uu; }
			bool operator()(pair<string, string > ds1, pair<string, string>ds2)
			{
				for (int i = 0; i < 3; i++)
				{
					if (ds1.first[i] - ds2.first[i] < 0)
						return true;
					else if (ds1.first[i] - ds2.first[i] > 0)
						return false;
				}
				for (int i = 0; i < 3; i++)
				{
					if (ds1.second[i] - ds2.second[i] < 0)
						return true;
					else if (ds1.second[i] - ds2.second[i] > 0)
						return false;
				}
				return false;
			}
		};
		std::sort(tickets.begin(), tickets.end(), compare(tickets));
		map<string, set<string>> ppp;
		map<pair<string, string>, int>count;
		for (int i = 0; i < tickets.size(); i++)
		{
			ppp[tickets[i].first].insert(tickets[i].second);
			count[tickets[i]]++;
		}
		vector<string>re;
		set<vector<string>>aa;

		re.push_back("JFK");

		while (true)
		{
			while (ppp[re.back()].size() > 0)
			{
				string str = re.back();
				re.push_back(*ppp[str].begin());
				count[pair<string, string>(str, re.back())]--;
				if (count[pair<string, string>(str, re.back())] == 0)
					ppp[str].erase(ppp[str].begin());
				if (re.size() == tickets.size() + 1)
					return re;
			}
			int kk = re.size() - 2;
			if (kk == 0)
			{
				string s = re[1];
				re.pop_back();
				re.push_back(*ppp[re[0]].begin());
				count[pair<string, string>(re[0], re.back())]--;
				if (count[pair<string, string>(re[0], re.back())] == 0)
					ppp[re[0]].erase(ppp[re[0]].begin());
				ppp[re[0]].insert(s);
				count[pair<string, string>(re[0], s)]++;
			}
			bool f = false;
			while (!f&&kk >= 1)
			{
				while (kk >= 1 && ppp[re[kk]].size() == 0)
				{
					kk--;
				}
				if (kk == 0)
				{
					for (int i = re.size() - 1; i > 1; i--)
					{
						string s = re.back();
						re.pop_back();
						ppp[re.back()].insert(s);
						count[pair<string, string>(re.back(), s)]++;
					}
					string s = re[1];
					re.pop_back();
					re.push_back(*ppp[re[0]].begin());
					count[pair<string, string>(re[0], re.back())]--;
					if (count[pair<string, string>(re[0], re.back())] == 0)
						ppp[re[0]].erase(ppp[re[0]].begin());
					ppp[re[0]].insert(s);
					count[pair<string, string>(re[0], s)]++;
					continue;
				}
				for (int j = kk; j < re.size() - 1; j++)
				{
					ppp[re[j]].insert(re[j + 1]);
					count[pair<string, string>(re[j], re[j + 1])]++;
				}
				aa.insert(vector<string>(re.begin(), re.begin() + kk + 2));
				re.erase(re.begin() + kk + 1, re.end());
				for (set<string>::iterator it = ppp[re.back()].begin(); it != ppp[re.back()].end(); it++)
				{
					vector<string>temp = re;
					temp.push_back(*it);
					if (aa.find(temp) == aa.end())
					{
						f = true;
						aa.insert(temp);
						count[pair<string, string>(re.back(), *it)]--;
						if (count[pair<string, string>(re.back(), *it)] == 0)
							ppp[re.back()].erase(it);
						re = temp;
						break;
					}
				}
				if (!f)
					kk--;
			}
			
		}

		finish = clock();
		Total_time = (double)(finish - start) / CLOCKS_PER_SEC;
		printf("%f seconds\n", Total_time);
	}
};

accept

不过话说现在看一个月前的代码感觉很low，不过也懒得改了



zbxzc
关注
专栏目录
用C语言实现Leetcode题目.zip
03-16
用C语言实现Leetcode题目.zip用C语言实现Leetcode题目.zip用C语言实现Leetcode题目.zip用C语言实现Leetcode题目.zip用C语言实现Leetcode题目.zip用C语言实现Leetcode题目.zip用C语言实现Leetcode题目.zip用C语言实现...
LeetCode 332. Reconstruct Itinerary（重构行程）
James Pan
04-29 1627
原题网址：https://leetcode.com/problems/reconstruct-itinerary/ Given a list of airline tickets represented by pairs of departure and arrival airports [from, to], reconstruct the itinerary in order.
leetcode 332 Reconstruct Itinerary
GadyPu的专栏
06-23 529
Reconstruct Itinerary
Leetcode 332. Reconstruct Itinerary[medium]
Proverbs
10-07 341
题目： 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
LeetCode_medium_332. Reconstruct Itinerary
逆时针
04-26 251
最近在刷Leetcode，希望以此来记录自己编写代码的一些想法。 一开始的思路： 从"JFK"开始找，得到与起点相连的终点，并且字母序最小，并将终点作为下一个起点，并将已经用完的tickets记录删除，继续找下一个终点，直至tickets都用完。 出现的bug在于：字母序最小的那个顺序可能会无解。 例如：[A,C],[A,D],[D,A] 规定从A开始。 如果按照我的算法：只能算到
排队(约瑟夫问题)用循环链表解决
GadyPu的专栏
10-19 769
描述 周末了，软件ACM的队员准备玩玩游戏，娱乐一下，CY想了一个好主意，所有队员站成一个圈，从1开始报数，凡是报出指定数字的人要出列，有人出列后，下个人重新从1开始报数。最后一位“幸存者”要给大家表演个节目。由于队员正在不断的壮大，C小加又想知道他是否需要准备表演，请你设计个程序，帮他确定他是否是“幸存者”。 输入第一行是n，有n次游戏，第二行是m，x，表示某次游戏有m个人，指定被请出列的数字
leetcode296-.leetcode:.leetcode
06-30
leetcode 296 .leetcode leetcode 刷题专用 日期 解决的题目 通过的提交 通过提交率 全站排名 2021/05/07 234/2074 381/601 63.39% 43409 2021/05/06 233/2073 380/600 63.33% 43607 2021/04/27 232/2063 379/599 63...
基于Java实现20道LeetCode题.pdf
08-14
基于Java实现20道LeetCode题.pdf
刷leetcode总结.md
11-15
刷leetcode总结.md
leetcode详解.zip_leetcode_leetcode详解
07-15
程序员招工组必备，leetcode刷题中文详解，迅速提升代码能力
leetcode笔记：Reconstruct Itinerary
liyuefeilong的专栏
04-11 3604
题目大意是，给定一组机票，用出发机场和到达机场的一对值[from, to]来表示，重建行程的顺序。所有的机票都从JFK（肯尼迪国际机场）出发。
332. Reconstruct Itinerary
hling_so的博客
10-15 187
332. Reconstruct Itinerary
用C语言分配动态二维数组(结构体实现)
GadyPu的专栏
09-27 5586
#include #include typedef struct { double **mat; int m; int n; }Matrix; void InitialMatrix(Matrix *T,int m,int n) { int i; T->mat=(double**)malloc(m*sizeof(double*)); for(i=0;i<m;i++) T->mat[i
LeetCode 332. Reconstruct Itinerary
zdinanyang的博客
04-25 403
题目【难度：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
leecode 解题总结：332. Reconstruct Itinerary
qingyuanluofeng的专栏
03-01 385
#include #include #include #include #include #include #include #include #include using namespace std; /* 问题: Given a list of airline tickets represented by pairs of departure and arrival airp
[LeetCode 332] Reconstruct Itinerary
coder 进阶的专栏
03-20 2764
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
332. Reconstruct Itinerary（C++实现）
jingmiaa的博客
05-13 955
算法思想： 将所有的机票用map保存，map<string,multimap<string>>，将val用multimap<string>保存，可以保存当前出发地能到达的所有的目的地。并且由于multimap会自动排序，最后得到的结果必定满足字典序最小． 利用DFS思想，用栈做中介，首先将"JFK"入栈，搜索map，将当前搜索的string入栈，直到map为空。开始从stack中取出string，加到结果res中。
LeetCode67. 一二进制求和
最新发布
10-05
LeetCode第67题是一个经典的二进制字符串相加问题，题目名称通常被称为“二进制加法”或者“两个数的二进制表示”。题目要求计算两个非负整数的二进制表示形式之和，这两个整数的每一位都是从最右边的0开始按顺序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值