Refactor find route solution

Use HashMap to redue time and space complexities.

Author: anitsh

src/talabat/route/README.MD

@@ -37,3 +37,68 @@ Output: “Halifax, Montreal, Toronto, Chicago, Winnipeg, Seattle”
 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)**	
+
+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/Solution.java

@@ -4,28 +4,85 @@
 
 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 < itineraries.length && startFound == false; i++) {
+        for (; i < itineraryLen && startFound == false; i++) {
             start = itineraries[i][0];
             int j = 0;
 
-            for (; j < itineraries.length; j++) {
+            for (; j < itineraryLen; j++) {
 
                 if (i != j && start == itineraries[j][1]) {
-                    j = itineraries.length + 1;
+                    j = itineraryLen + 1;
                 }
             }
 
-            if (j == itineraries.length) {
+            if (j == itineraryLen) {
                 startFound =true;
             }
         }
@@ -34,16 +91,17 @@ public int findStartingIndex(String[][] itineraries) {
     }
 
     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 < itineraries.length+1; l++) {
+        for (int l = 0; l < itineraryLen+1; l++) {
 
             if ( traversedIndex.containsKey(l) == false ) {
                 int m = 0;
-                for (; m < itineraries.length; m++) {
+                for (; m < itineraryLen; m++) {
 
                     if ( traversedIndex.containsKey(m) == false
                             && nextStart == itineraries[m][0]) {

src/talabat/route/SolutionTest.java

@@ -45,7 +45,7 @@ void shouldPassWithExample2() {
                 {"Winnipeg", "Seattle"}
         };
         String expected = "Halifax, Montreal, Toronto, Chicago, Winnipeg, Seattle";
-        Assertions.assertEquals(solution.trackRoute(itineraries), expected);
+        Assertions.assertEquals(expected, solution.trackRoute(itineraries));
     }
 
     @Test
@@ -60,7 +60,7 @@ void shouldPassWithExample2Suffled() {
                 {"Winnipeg", "Seattle"}
         };
         String expected = "Halifax, Montreal, Toronto, Chicago, Winnipeg, Seattle";
-        Assertions.assertEquals(solution.trackRoute(itineraries), expected);
+        Assertions.assertEquals(expected, solution.trackRoute(itineraries));
     }
 
     @Test
@@ -73,4 +73,19 @@ void shouldPassWithASingleInput() {
         Assertions.assertEquals(expected, solution.trackRoute(itineraries));
     }
 
+    @Test
+    void shouldPassWithExample2AddOne() {
+
+        Solution solution = new Solution();
+        String[][] itineraries = {
+                {"Montreal", "Toronto"},
+                {"Toronto", "Chicago"},
+                {"Chicago", "Winnipeg"},
+                {"Halifax", "Montreal"},
+                {"Winnipeg", "Seattle"},
+                {"Seattle", "Boston"}
+        };
+        String expected = "Halifax, Montreal, Toronto, Chicago, Winnipeg, Seattle, Boston";
+        Assertions.assertEquals(expected, solution.trackRoute(itineraries));
+    }
 }