use dp cache for balanced partition

Author: justcoding121

Advanced.Algorithms.Tests/DynamicProgramming/Sequence/BalancedPartition_Tests.cs

@@ -20,16 +20,7 @@ public void Partition_Smoke_Test()
         {
             var input = new int[] { 3, 1, 1, 2, 2, 1, 4 , 2};
 
-            var partitionA = BalancedPartition.FindPartition(input);
-
-            Assert.AreEqual(8, partitionA
-                .Select(i => input[i])
-                .Sum());
-
-            var partitionB = input.Where((x, i) => !partitionA.Contains(i)).ToList();
-
-            Assert.AreEqual(8, 
-                partitionB.Sum());
+            Assert.IsTrue(BalancedPartition.CanPartition(input));
         }
     }
 }

Advanced.Algorithms/DynamicProgramming/Sequence/BalancedPartition.cs

@@ -13,66 +13,61 @@ public class BalancedPartition
         /// </summary>
         /// <param name="input"></param>
         /// <returns></returns>
-        public static List<int>
-            FindPartition(int[] input)
+        public static bool
+            CanPartition(int[] input)
         {
             var sum = FindSum(input);
 
             if (sum % 2 == 1)
             {
                 //cannot partition
-                return new List<int>();
+                return false;
             }
 
-            var result = new List<int>();
-
-            var canPartition = Partition(sum / 2, input, 0, 0, result);
-
-            return result;
+            return CanPartition(input, input.Length - 1, sum / 2, new Dictionary<string, bool>());
 
         }
 
-        /// <summary>
-        /// Dynamic recursion
-        /// </summary>
-        /// <param name="sum"></param>
-        /// <param name="input"></param>
-        /// <param name="index"></param>
-        /// <param name="progress"></param>
-        /// <param name="pickedIndices"></param>
-        /// <returns></returns>
-        private static bool Partition(int sum,
-            int[] input, int index,
-            int progress, 
-            List<int> pickedIndices)
+        private static bool CanPartition(int[] input, int i, int sum,
+            Dictionary<string, bool> cache)
         {
-            //found result
-            if (sum == 0)
+            if (i < 0)
             {
-                return true;
+                return false;
             }
 
-            //cannot pick this value
-            //which is greater than current sum
-            if (input[index] > sum)
+            //found a partition
+            if (input[i] == sum)
             {
-                return Partition(sum, input, index + 1, progress, pickedIndices);
+                return true;
             }
 
-            //pick current element
-            var canPartition = Partition(sum - input[index], input,
-                index + 1, progress + 1, pickedIndices);
+            var cacheKey = $"{i}-{sum}";
+
+            if (cache.ContainsKey(cacheKey))
+            {
+                return cache[cacheKey];
+            }
 
-            if (canPartition)
+            bool result;
+            //cannot pick anyway
+            if (input[i] > sum)
             {
-                pickedIndices.Add(index);
-                return canPartition;
+                result = CanPartition(input, i - 1, sum, cache);
+                cache.Add(cacheKey, result);
+                return result;
             }
 
-            //skip current element
-            canPartition = Partition(sum, input, index + 1, progress, pickedIndices);
+            //skip or pick
+            result = CanPartition(input, i - 1, sum, cache)
+                || CanPartition(input, i - 1, sum - input[i], cache);
 
-            return canPartition;
+            if (!cache.ContainsKey(cacheKey))
+            {
+                cache.Add(cacheKey, result);
+            }
+
+            return result;
         }
 
         private static int FindSum(int[] input)

Advanced.Algorithms/DynamicProgramming/TowerOfHanoi.cs

@@ -24,8 +24,6 @@ public static int Tower(int numOfDisks)
         /// <param name="moveCount"></param>
         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);
-
             if (n == 1)
             {
                 return 1;
@@ -36,20 +34,13 @@ private static int Tower(int n, string source, string aux, string dest, Dictiona
                 return cache[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);
-
-            ////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)
+                        //+1 for current move
+                        + Tower(n - 1, source, dest, aux, cache) + 1;
 
-            //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);