add cache

Author: justcoding121

Advanced.Algorithms/DynamicProgramming/Count/CountBinaryTree.cs

@@ -1,4 +1,6 @@
-namespace Advanced.Algorithms.DynamicProgramming.Count
+using System.Collections.Generic;
+
+namespace Advanced.Algorithms.DynamicProgramming.Count
 {
     /// <summary>
     /// Problem statement below
@@ -8,7 +10,7 @@ public class CountBinaryTree
     {
         public static int Count(int n)
         {
-            return Count(0, n);
+            return Count(0, n, new Dictionary<string, int>());
         }
 
         /// <summary>
@@ -21,7 +23,7 @@ public static int Count(int n)
         /// <param name="start"></param>
         /// <param name="end"></param>
         /// <returns></returns>
-        private static int Count(int start, int end)
+        private static int Count(int start, int end, Dictionary<string, int> cache)
         {
             if (start > end)
             {
@@ -34,15 +36,25 @@ private static int Count(int start, int end)
                 return 1;
             }
 
+            var cacheKey = $"{start}-{end}";
+
+            if(cache.ContainsKey(cacheKey))
+            {
+                return cache[cacheKey];
+            }
+
+
             var count = 0;
 
             //break in to left & right
             for (int i = start; i < end; i++)
             {
-                count += Count(start, i)
-                         * Count(i + 1, end);
+                count += Count(start, i, cache)
+                         * Count(i + 1, end, cache);
             }
 
+            cache.Add(cacheKey, count);
+
             return count;
         }
     }

Advanced.Algorithms/DynamicProgramming/Matrix/MinCostMatrixPath.cs

@@ -14,10 +14,10 @@ public class MinCostMatrixPath
     {
         public static int FindPath(int[,] matrix)
         {
-            return FindPath(matrix, 0, 0);
+            return FindPath(matrix, 0, 0, new Dictionary<string, int>());
         }
 
-        private static int FindPath(int[,] matrix, int i, int j)
+        private static int FindPath(int[,] matrix, int i, int j, Dictionary<string, int> cache)
         {
             if (i >= matrix.GetLength(0)
                 || j >= matrix.GetLength(1))
@@ -31,13 +31,24 @@ private static int FindPath(int[,] matrix, int i, int j)
                 return matrix[i, j];
             }
 
+            var cacheKey = $"{i}-{j}";
+
+            if(cache.ContainsKey(cacheKey))
+            {
+                return cache[cacheKey];
+            }
+
             var pathResults = new List<int>();
 
-            pathResults.Add(FindPath(matrix, i + 1, j + 1));
-            pathResults.Add(FindPath(matrix, i, j + 1));
-            pathResults.Add(FindPath(matrix, i + 1, j));
+            pathResults.Add(FindPath(matrix, i + 1, j + 1, cache));
+            pathResults.Add(FindPath(matrix, i, j + 1, cache));
+            pathResults.Add(FindPath(matrix, i + 1, j, cache));
+
+            var result = pathResults.Min() + matrix[i, j];
+
+            cache.Add(cacheKey, result);
 
-            return pathResults.Min() + matrix[i, j];
+            return result;
         }
     }
 }

Advanced.Algorithms/DynamicProgramming/TowerOfHanoi.cs

@@ -1,4 +1,5 @@
-using System.Diagnostics;
+using System.Collections.Generic;
+using System.Diagnostics;
 
 namespace Advanced.Algorithms.DynamicProgramming
 {
@@ -10,11 +11,7 @@ public class TowerOfHanoi
     {
         public static int Tower(int numOfDisks)
         {
-            var minMoves = 0;
-
-            Tower(numOfDisks, "a", "b", "c", ref minMoves);
-
-            return minMoves;
+            return Tower(numOfDisks, "a", "b", "c", new Dictionary<int, int>());
         }
 
         /// <summary>
@@ -25,29 +22,39 @@ public static int Tower(int numOfDisks)
         /// <param name="aux"></param>
         /// <param name="dest"></param>
         /// <param name="moveCount"></param>
-        private static void Tower(int n, string source, string aux, string dest, ref int moveCount)
+        private static int Tower(int n, string source, string aux, string dest, Dictionary<int, int> cache)
         {
             Debug.WriteLine("Moving disc {0} from pole {1} to {2}", n, source, dest);
 
-            moveCount++;
+            if (n == 1)
+            {
+                return 1;
+            }
 
-            if (n > 1)
+            if (cache.ContainsKey(n))
             {
-                ////assume without last disc on top we would be moving a disc from source to dest
-                //Tower(n - 1, source, aux, dest, ref moveCount);
+                return cache[n];
+            }
 
-                ////The last disc we just moved above to destination was in source
-                ////that disc was definitely moved from aux to source (if it was in destination we would be not here)
-                //Tower(n - 1, aux, dest, source, ref moveCount);
+            ////assume without last disc on top we would be moving a disc from source to dest
+            //Tower(n - 1, source, aux, dest, ref moveCount);
 
-                //or alternatively
-                //assume without last disc on top we would be moving a disc from aux to dest
-                Tower(n - 1, aux, source, dest, ref moveCount);
+            ////The last disc we just moved above to destination was in source
+            ////that disc was definitely moved from aux to source (if it was in destination we would be not here)
+            //Tower(n - 1, aux, dest, source, ref moveCount);
+
+            //or alternatively
+            //assume without last disc on top we would be moving a disc from aux to dest
+            var result = Tower(n - 1, aux, source, dest, cache)
+
+            //The last disc we just moved above to destination was in aux
+            //that disc was definitely moved from source to aux (if it was in destination we would be done by now)
+            + Tower(n - 1, source, dest, aux, cache) + 1;
+
+            cache.Add(n, result);
+
+            return result;
 
-                //The last disc we just moved above to destination was in aux
-                //that disc was definitely moved from source to aux (if it was in destination we would be done by now)
-                Tower(n - 1, source, dest, aux, ref moveCount);
-            }
         }
 
     }