Merge branch 'master' into leetcode-containsduplicate-three

Author: anitsh

.idea/uiDesigner.xml

@@ -0,0 +1,108 @@
+# Problem
+
+We are tracking down our rouge agent and she 
+travels from place to place to **avoid being tracked**. 
+
+Each of her travels are based on a list of itineraries 
+in an unusual or incorrect order. 
+
+The task is to 
+determine the complete **route** she will take. 
+
+You are given and array of routes containing her 
+travel itineraries, convert this into a complete, 
+**in-order list** of the places she will travel. 
+
+Specifications: findRoutes(routes) parameters: 
+routes: array<array<string>> - array of itineraries
+
+return value: **string**: **an order list of distinations**
+
+**the correct path she took**
+
+constraints: all inputs have at least one valid, 
+complete route examples: 
+
+input: [[“USA”, “BRA”],[“JPN”, “CAI”], [“BRA”, “UAE”],[“UAE”, “JPN”]] 
+Output: “USA, BRA, UAE, JPN, CAI” 
+
+input: [["Chicago", "Winnipeg"], ["Halifax", "Montreal"], 
+["Montreal", "Toronto"], ["Toronto", "Chicago"], ["Winnipeg", "Seattle"]] 
+Output: “Halifax, Montreal, Toronto, Chicago, Winnipeg, Seattle” 
+
+# Solution
+
+## Bruteforce Approach
+### Pseudocode
+1. Find the starting point
+2. Create route
+
+## Refactor
+Let's review the input again
+[“USA”, “BRA”],[“JPN”, “CAI”], [“BRA”, “UAE”],[“UAE”, “JPN”]
+
+The path is acyclic - there is one start and destination.
+
+[“USA”, “BRA”],
+[“JPN”, “CAI”], 
+[“BRA”, “UAE”],
+[“UAE”, “JPN”]
+
+It looks like a key value pair.
+First solutions time complexity is O(n^2).
+Can storing the values in a hashmap improve 
+time complexity? Or simplify our solution?
+
+Let's store the input in the hashmap.
+
+[“USA” => “BRA”],
+[“JPN” => “CAI”],
+[“BRA” => “UAE”],
+[“UAE” => “JPN”]
+
+The basic solution remains the same.
+1. Find starting point
+2. Make route
+
+### Find starting point
+The starting point is such a key that
+would not appear as a value.
+
+We need to find the key such that it
+does not appear as the value of other
+pairs.
+
+Hashmap has a functionality to check
+value exists.
+
+**boolean containsValue(Object value)**	
+
+The probable time complexity of this function
+is O(n).
+https://stackoverflow.com/questions/55679728/how-does-java-util-hashmap-containsvalue-work-what-is-its-time-complexity
+
+This method returns true if some value 
+equals to the value exists within the map, 
+else return false.
+
+So we iterate through all the pairs until
+containsValue returns false.
+
+### Make route
+We have the starting point as the key
+from one of the pairs.
+
+Route is created such a way that value
+of a pair (destination) must be the key
+of other (source). 
+
+The final destination does not have another
+source.
+
+So to create a route, first we need to 
+find the key of another pair which is
+the value of the current key.
+
+This is our simple solution to make a
+route.
+

src/talabat/route/README.MD

@@ -0,0 +1,119 @@
+package talabat.route;
+
+import java.util.HashMap;
+
+class Solution {
+
+    public String trackRoute(String[][] itineraries) {
+        String route = "";
+        int itineraryLen = itineraries.length;
+
+        if( itineraryLen == 1 ) {
+            return itineraries[0][0] + ", " + itineraries[0][1];
+        }
+
+//        1. Transform to hashmap
+//        2. Find starting point
+//        3. Make route
+
+
+//        Transform to hashmap
+        HashMap<String, String> itinerariesMap = new HashMap<>();
+
+        for (int i=0; i<itineraryLen; i++) {
+            itinerariesMap.put(itineraries[i][0],itineraries[i][1]);
+        }
+
+//        Find starting point
+        boolean foundStart = false;
+        String start = "";
+        for ( int i=0; i < itineraryLen && foundStart == false; i++ ) {
+            start = itineraries[i][0];
+
+            if ( !itinerariesMap.containsValue(start) )
+                foundStart = true;
+        }
+
+//        Make route
+        String end = itinerariesMap.get(start);
+        route += start + ", " + end;
+
+//        As we can take start and end at once,
+//        find the number of iterations to make
+        int loop = itineraryLen/2 + itineraryLen%2 - 1;
+
+        for ( int i=0; i<loop; i++ ) {
+            start = itinerariesMap.get(end);
+            end = itinerariesMap.get(start);
+            route += ", " + start + ", " + end;
+
+        }
+
+//        Last destination is missed when itineraries
+//        length is even
+        if ( itineraryLen % 2 == 0 )
+            route += ", " + itinerariesMap.get(end);
+
+        return route;
+    }
+}
+
+class SolutionLegacy {
+
+    public String trackRoute(String[][] itineraries) {
+        int startIndex = this.findStartingIndex(itineraries);
+        return this.createPath(startIndex, itineraries);
+    }
+
+    public int findStartingIndex(String[][] itineraries) {
+        int itineraryLen = itineraries.length;
+        String start = "";
+        boolean startFound = false;
+        int i = 0;
+
+        for (; i < itineraryLen && startFound == false; i++) {
+            start = itineraries[i][0];
+            int j = 0;
+
+            for (; j < itineraryLen; j++) {
+
+                if (i != j && start == itineraries[j][1]) {
+                    j = itineraryLen + 1;
+                }
+            }
+
+            if (j == itineraryLen) {
+                startFound =true;
+            }
+        }
+
+        return i-1;
+    }
+
+    public String createPath(int startIndex, String[][] itineraries) {
+        int itineraryLen = itineraries.length;
+        String route = itineraries[startIndex][0] + ", " + itineraries[startIndex][1];
+        String nextStart = itineraries[startIndex][1];
+        HashMap<Integer, Boolean> traversedIndex = new HashMap<Integer, Boolean>();
+        traversedIndex.put(startIndex, true);
+
+        for (int l = 0; l < itineraryLen+1; l++) {
+
+            if ( traversedIndex.containsKey(l) == false ) {
+                int m = 0;
+                for (; m < itineraryLen; m++) {
+
+                    if ( traversedIndex.containsKey(m) == false
+                            && nextStart == itineraries[m][0]) {
+                        nextStart = itineraries[m][1];
+                        route += ", " + itineraries[m][1];
+                        traversedIndex.put(m, true);
+                    }
+                }
+            }
+        }
+
+        return route;
+    }
+
+}