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.
  4. One must use all the tickets once and only once.

Example 1:

Input: [["MUC", "LHR"], ["JFK", "MUC"], ["SFO", "SJC"], ["LHR", "SFO"]]
Output: ["JFK", "MUC", "LHR", "SFO", "SJC"]

Example 2:

Input: [["JFK","SFO"],["JFK","ATL"],["SFO","ATL"],["ATL","JFK"],["ATL","SFO"]]
Output: ["JFK","ATL","JFK","SFO","ATL","SFO"]
Explanation: Another possible reconstruction is ["JFK","SFO","ATL","JFK",
                  "ATL","SFO"].
             But it is larger in lexical order.
 class Solution {
    Map<String, PriorityQueue<String>> map = new HashMap<>();
    LinkedList<String> list = new LinkedList<>();
    public List<String> findItinerary(List<List<String>> t) {
        for(List<String> e : t){
            String from = e.get(0), to = e.get(1);
            if(!map.containsKey(from))
                map.put(from, new PriorityQueue<>());
            map.get(from).add(to);
        }
        itineraryHelper("JFK");
        return list;
    }
    private void itineraryHelper(String str){
        PriorityQueue<String> pq = map.get(str);
        while(pq != null && !pq.isEmpty())
            itineraryHelper(pq.poll());
        list.addFirst(str);
    }
}


Here, we are going to create graph using Map with string as key and priority queue as value(inorder to store in lexical order).  We can also try using TreeSet but there is a possibility of multiple tickets for (u,v).
1) Store source and destinations in a map. If a source is already present, then add destination to PriorityQueue. Else add a source to map and create a new PriorityQueue with destination.
2) Call itineraryHelper() from "JFK"
3) From this method, with help of PriorityQueue add all destinations to result list in lexical order(already stored in map)

This problem is application of Eulerian Path


Click Follow button to receive updates from us instantly.

Please let us know about your views in comment section.
                                                     😍..Happy Coding...😍
The intention behind this blog is to help all my fellow programmers. Also to provide solutions for various coding platform problems with solution and explanation. I will add many tutorials in future. I am not a professional blogger but whenever time permits I will post. I hope you’ll enjoy the content and find it useful! Check out my Writer blog for a more valuable quotes. For any queries or suggestions, please feel free to reach out to me. Happy coding!

Comments

Post a Comment

Popular posts from this blog

First Unique Character in a String

Given a string, find the first non-repeating character in it and return it's index. If it doesn't exist, return -1. Examples: s = "leetcode" return 0. s = "loveleetcode", return 2. Note: You may assume the string contain only lowercase letters. class Solution {     public int firstUniqChar(String s) {         int length = s.length();         String str;         for(int i=0;i<length;i++){             if(i==length-1){                 str = s.substring(0, i);             }             else{                 str = s.substring(0,i)+s.substring(i+1);             }             if(!str.contains(s.charAt(i)+""))                 return i;         }         return -1;     } } Try it on Leetcode Here, we are going to use substring method. 1) If character is at end, then take substring from 0 till before last character of string. 2) Else make a temporary string, by removing exactly that particular character using index. [e.g..
Read more

Balanced Binary Tree

Given a binary tree, determine if it is height-balanced. For this problem, a height-balanced binary tree is defined as: a binary tree in which the left and right subtrees of  every  node differ in height by no more than 1. Example 1: Input: root = [3,9,20,null,null,15,7] Output: true Example 2: Input: root = [1,2,2,3,3,null,null,4,4] Output: false Example 3: Input: root = [] Output: true   Constraints: The number of nodes in the tree is in the range  [0, 5000] . -10 4  <= Node.val <= 10 4 Solution: /**  * Definition for a binary tree node.  * public class TreeNode {  *     int val;  *     TreeNode left;  *     TreeNode right;  *     TreeNode() {}  *     TreeNode(int val) { this.val = val; }  *     TreeNode(int val, TreeNode left, TreeNode right) {  *         this.val = val;  *         this.left = left;  *         this.right = right;  *     }
Read more

Majority Element

Given an array of size n , find the majority element. The majority element is the element that appears more than ⌊ n/2 ⌋ times. You may assume that the array is non-empty and the majority element always exist in the array. Example 1: Input: [3,2,3] Output: 3 Example 2: Input: [2,2,1,1,1,2,2] Output: 2   class Solution { public int majorityElement(int[] nums) { Arrays.sort(nums); return nums[nums.length/2]; } } Here, we are sorting the entire array using sort() of Arrays class. Then, number at index position n/2 would be a majority element. There is no chance of wrong values in odd or even length.   Below is another method using HashMap. METHOD 2: class Solution { public int majorityElement(int[] nums) { HashMap<Integer, Integer>list = new HashMap<Integer, Integer>(); int repeatLen
Read more

Smallest Range II

Given an array   A   of integers, for each integer   A[i]   we need to choose   either  x = -K  or  x = K , and add   x   to   A[i]  (only once) . After this process, we have some array  B . Return the smallest possible difference between the maximum value of  B  and the minimum value of  B . Example 1: Input: A = [1] , K = 0 Output: 0 Explanation : B = [1] Example 2: Input: A = [0,10] , K = 2 Output: 6 Explanation : B = [2,8] Example 3: Input: A = [1,3,6] , K = 3 Output: 3 Explanation : B = [4,6,3] Note: 1 <= A.length <= 10000 0 <= A[i] <= 10000 0 <= K <= 10000 Solution: class Solution {     public int smallestRangeII(int[] A, int K) {         int i, min=0, max=0, min1, min2, max1, max2, length = A.length, diff
Read more