 GFG App
Open App Browser
Continue

# Find Itinerary from a given list of tickets

Given a list of tickets, find itinerary in order using the given list.

Example:

```Input:
"Chennai" -> "Banglore"
"Bombay" -> "Delhi"
"Goa"    -> "Chennai"
"Delhi"  -> "Goa"

Output:
Bombay->Delhi, Delhi->Goa, Goa->Chennai, Chennai->Banglore,```

It may be assumed that the input list of tickets is not cyclic and there is one ticket from every city except the final destination.

One Solution is to build a graph and do Topological Sorting of the graph. The time complexity of this solution is O(n).

We can also use hashing to avoid building a graph. The idea is to first find the starting point. A starting point would never be on ‘to’ side of a ticket. Once we find the starting point, we can simply traverse the given map to print itinerary in order. The following are steps.

```1) Create a HashMap of given pair of tickets.  Let the created
HashMap be 'dataset'. Every entry of 'dataset' is of the form
"from->to" like "Chennai" -> "Banglore"

2) Find the starting point of itinerary.
a) Create a reverse HashMap.  Let the reverse be 'reverseMap'
Entries of 'reverseMap' are of the form "to->form".
Following is 'reverseMap' for above example.
"Banglore"-> "Chennai"
"Delhi"   -> "Bombay"
"Chennai" -> "Goa"
"Goa"     ->  "Delhi"

b) Traverse 'dataset'.  For every key of dataset, check if it
is there in 'reverseMap'.  If a key is not present, then we
found the starting point. In the above example, "Bombay" is
starting point.

3) Start from above found starting point and traverse the 'dataset'
to print itinerary.```

All of the above steps require O(n) time so overall time complexity is O(n).

Below is Java implementation of above idea.

## C++

 `#include ` `using` `namespace` `std;`   `void` `printItinerary(map dataSet)` `{` `    ``// To store reverse of given map` `    ``map reversemap;` `    ``map::iterator it;`   `    ``// To fill reverse map, iterate through the given map` `    ``for` `(it = dataSet.begin(); it!=dataSet.end(); it++)` `        ``reversemap[it->second] = it->first;`   `    ``// Find the starting point of itinerary` `    ``string start;`   `    ``for` `(it = dataSet.begin(); it!=dataSet.end(); it++)` `    ``{` `        ``if` `(reversemap.find(it->first) == reversemap.end())` `        ``{` `            ``start = it->first;` `            ``break``;` `        ``}` `    ``}`   `    ``// If we could not find a starting point, then something wrong with input` `     ``if` `(start.empty())` `     ``{` `        ``cout << ``"Invalid Input"` `<< endl;` `        ``return``;` `     ``}`   `    ``// Once we have starting point, we simple need to go next,` `    ``//next of next using given hash map` `    ``it = dataSet.find(start);` `    ``while` `(it != dataSet.end())` `    ``{` `        ``cout << it->first << ``"->"` `<< it->second << endl;` `        ``it = dataSet.find(it->second);` `    ``}`   `}`   `int` `main()` `{` `    ``map dataSet;` `    ``dataSet[``"Chennai"``] = ``"Banglore"``;` `    ``dataSet[``"Bombay"``] = ``"Delhi"``;` `    ``dataSet[``"Goa"``] = ``"Chennai"``;` `    ``dataSet[``"Delhi"``] = ``"Goa"``;`   `    ``printItinerary(dataSet);`   `    ``return` `0;` `}` `// C++ implementation is contributed by Aditya Goel`

## Java

 `// Java program to print itinerary in order` `import` `java.util.HashMap;` `import` `java.util.Map;`   `public` `class` `printItinerary` `{` `    ``// Driver function` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``Map dataSet = ``new` `HashMap();` `        ``dataSet.put(``"Chennai"``, ``"Banglore"``);` `        ``dataSet.put(``"Bombay"``, ``"Delhi"``);` `        ``dataSet.put(``"Goa"``, ``"Chennai"``);` `        ``dataSet.put(``"Delhi"``, ``"Goa"``);`   `        ``printResult(dataSet);` `    ``}`   `    ``// This function populates 'result' for given input 'dataset'` `    ``private` `static` `void` `printResult(Map dataSet)` `    ``{` `        ``// To store reverse of given map` `        ``Map reverseMap = ``new` `HashMap();`   `        ``// To fill reverse map, iterate through the given map` `        ``for` `(Map.Entry entry: dataSet.entrySet())` `            ``reverseMap.put(entry.getValue(), entry.getKey());`   `        ``// Find the starting point of itinerary` `        ``String start = ``null``;` `        ``for` `(Map.Entry entry: dataSet.entrySet())` `        ``{` `              ``if` `(!reverseMap.containsKey(entry.getKey()))` `              ``{` `                   ``start = entry.getKey();` `                   ``break``;` `              ``}` `        ``}`   `        ``// If we could not find a starting point, then something wrong` `        ``// with input` `        ``if` `(start == ``null``)` `        ``{` `           ``System.out.println(``"Invalid Input"``);` `           ``return``;` `        ``}`   `        ``// Once we have starting point, we simple need to go next, next` `        ``// of next using given hash map` `        ``String to = dataSet.get(start);` `        ``while` `(to != ``null``)` `        ``{` `            ``System.out.print(start +  ``"->"` `+ to + ``", "``);` `            ``start = to;` `            ``to = dataSet.get(to);` `        ``}` `    ``}` `}`

## Python3

 `class` `Solution():` `    ``#Solution class carries method for printing itinerary` `    ``def` `__init__(``self``):` `        ``pass` `    ``#method for printing itinerary` `    ``def` `printItinerary(``self``,d):` `        ``# First step : create a reversed mapping. Here also for storing key value pairs dictionary is used.` `        ``reverse_d ``=` `dict``()` `        ``for` `i ``in` `d:` `            ``reverse_d[d[i]] ``=` `i` `        ``# Second step : find the starting point. Starting point will be that value which is not present in 'd' as key.` `        ``for` `i ``in` `reverse_d:` `            ``if` `reverse_d[i] ``not` `in` `reverse_d:` `                ``starting_pt ``=` `reverse_d[i]` `                ``break``;` `        ``#Third step : simply proceed one by one to print whole route. Assuming that there exist Starting point.` `        ``while``(starting_pt ``in` `d):` `            ``print``(starting_pt,``"->"``,d[starting_pt],end``=``", "``)` `            ``starting_pt ``=` `d[starting_pt]` `        ``#method prints here only. Does not return anything.`     `if` `__name__``=``=``"__main__"``:` `    ``# Mapping using inbuilt data structure 'dictionary'` `    ``d ``=` `dict``()` `    ``d[``"Chennai"``] ``=` `"Banglore"` `    ``d[``"Bombay"``] ``=` `"Delhi"` `    ``d[``"Goa"``] ``=` `"Chennai"` `    ``d[``"Delhi"``] ``=` `"Goa"`   `    ``# call for method that would print itinerary.` `    ``obj ``=` `Solution()` `    ``obj.printItinerary(d)`

## C#

 `// C# program to print itinerary in order` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `printItinerary` `{` `  ``// Driver function` `  ``public` `static` `void` `Main(``string``[] args)` `  ``{` `    ``Dictionary<``string``, ``string``> dataSet = ``new` `Dictionary<``string``, ``string``>();` `    ``dataSet[``"Chennai"``] = ``"Banglore"``;` `    ``dataSet[``"Bombay"``] = ``"Delhi"``;` `    ``dataSet[``"Goa"``] = ``"Chennai"``;` `    ``dataSet[``"Delhi"``] = ``"Goa"``;`   `    ``printResult(dataSet);` `  ``}`   `  ``// This function populates 'result' for given input 'dataset'` `  ``private` `static` `void` `printResult( Dictionary<``string``, ``string``> dataSet)` `  ``{`   `    ``// To store reverse of given map` `    ``Dictionary<``string``, ``string``> reverseMap = ``new`  `Dictionary<``string``, ``string``>();`   `    ``// To fill reverse map, iterate through the given map` `    ``foreach` `(``var` `entry ``in` `dataSet)` `      ``reverseMap[entry.Value] = entry.Key;`   `    ``// Find the starting point of itinerary` `    ``string` `start = ``null``;` `    ``foreach` `(``var` `entry ``in` `dataSet)` `    ``{` `      ``if` `(!reverseMap.ContainsKey(entry.Key))` `      ``{` `        ``start = entry.Key;` `        ``break``;` `      ``}` `    ``}`   `    ``// If we could not find a starting point, then something wrong` `    ``// with input` `    ``if` `(start == ``null``)` `    ``{` `      ``Console.WriteLine(``"Invalid Input"``);` `      ``return``;` `    ``}`   `    ``// Once we have starting point, we simple need to go next, next` `    ``// of next using given hash map` `    ``string` `to = dataSet[start];` `    ``while` `(``true``) ` `    ``{` `      ``Console.Write(start +  ``"->"` `+ to + ``", "``);` `      ``start = to;` `      ``if` `(!dataSet.ContainsKey(to))` `        ``break``;` `      ``to = dataSet[to];` `    ``}` `  ``}` `}`     `// This code is contributed by phasing17`

## Javascript

 `// JavaScript approach to sollve the problem`   `function` `printItinerary(dataSet)` `{` `    ``// To store reverse of given map` `    ``let reversemap = ``new` `Map();`   `    ``// To fill reverse map, iterate through the given map` `    ``for` `(const[key,value] of dataSet)` `        ``reversemap.set(value,key);`   `    ``// Find the starting point of itinerary` `    ``let start = ``""``;`   `    ``for` `(const key of dataSet.keys())` `    ``{` `        ``if` `(!reversemap.has(key))` `        ``{` `            ``start = key;` `            ``break``;` `        ``}` `    ``}`   `    ``// If we could not find a starting point, then something wrong with input` `     ``if` `(start.length == 0)` `     ``{` `        ``console.log(``"Invalid Input"``);` `        ``return``;` `     ``}`   `    ``// Once we have starting point, we simple need to go next,` `    ``//next of next using given hash map` `    ``let it = start;` `    ``while` `(dataSet.has(it))` `    ``{` `        ``console.log(it+``"->"``+dataSet.get(it));` `        ``it = dataSet.get(it);` `    ``}`   `}`   `// driver code`   `let dataSet = ``new` `Map();` `dataSet.set(``"Chennai"``,``"Banglore"``);` `dataSet.set(``"Bombay"``,``"Delhi"``);` `dataSet.set(``"Goa"``,``"Chennai"``);` `dataSet.set(``"Delhi"``,``"Goa"``);` `printItinerary(dataSet);`   `//code is contributed by shinjanpatra`

Output

`Bombay->Delhi, Delhi->Goa, Goa->Chennai, Chennai->Banglore, `

Time Complexity: O(n).
Auxiliary Space: O(n), The extra space is used in map.

My Personal Notes arrow_drop_up