Merge pull request #14 from dpalmasan/issue-10-improvement

Optimizar en memoria sum abs diff (#10)

python/sols/arrays/prefix_sum_problems.py

@@ -16,14 +16,12 @@ def sum_absolute_differences(nums: List[int]) -> List[int]:
     :rtype: List[int]
     """
     n = len(nums)
-    prefix = [0]*(n + 1)
-    for i in range(1, len(nums) + 1):
-        prefix[i] = prefix[i - 1] + nums[i - 1]
-
+    total_sum = sum(nums)  
     result = [0]*n
+    cum_sum = 0
+    cum_sum_next = 0
     for i in range(n):
-        result[i] = (
-            prefix[n] - prefix[i + 1] - nums[i]*(n - i - 1)
-            - prefix[i] + nums[i]*i
-        )
+        cum_sum_next += nums[i]
+        result[i] = total_sum - cum_sum_next - nums[i]*(n - i - 1) + nums[i]*i - cum_sum
+        cum_sum += nums[i]
     return result

sols-expl/arrays/README.md

@@ -187,5 +187,31 @@ algoritmo sum-abs-diff
 
 En este caso podemos observar un intercambio memoria/tiempo de ejecución, ya que ahora la complejidad en tiempo de ejecución es `O(N)`, y la complejidad en memoria es también `O(N)` ya que necesitamos pre-calcular la suma acumulada.
 
+### Enfoque optimizado en memoria
+
+Tomando ideas del enfoque optimizado, podemos darnos cuenta que no necesitamos pre-calcular la suma acumulada, y podemos hacer el cálculo _in place_ si modificamos el algoritmo como sigue:
+
+```
+algoritmo sum-abs-diff-mem-opt
+  entrada: nums: int[]
+  salida: result: int[]
+  
+  total_sum = 0
+  for i in 1 to N:
+    total_sum += nums[i]
+
+  result = new int[nums.length]
+  cum_sum = 0
+  cum_sum_next = 0
+  for i = 0 to N - 1:
+    cum_sum_next += nums[i]
+    result[i] = total_sum - cum_sum_next - nums[i] * (n - i - 1) - cum_sum + nums[i] * i
+    cum_sum += nums[i]
+
+  return result
+```
+
+En este caso, la complejidad en tiempo es `O(N)`, pero se redujo la complejidad en memoria a `O(1)`.
+
 [i3]: https://github.com/dpalmasan/code-challenges/issues/3
 [i10]: https://github.com/dpalmasan/code-challenges/issues/10