[Algorithm] Largest sum of non-adjacent numbers

Given a list of integers, write a function that returns the largest sum of non-adjacent numbers. Numbers can be 0 or negative.

For example, [2, 4, 6, 2, 5] should return 13, since we pick 2, 6, and 5. [5, 1, 1, 5] should return 10, since we pick 5 and 5.

Follow-up: Can you do this in O(N) time and constant space

How to think?

Always start from make few assumption / examples to see the parttens:

For example:

[5,1,1,5]

Start from i = 0: max sum can be Math.max(5, 0)

// memo: [5]

Then i = 1: max sum can be Math.max(memo[0], arr[1]), which is memo[1] = Math.max(5, 1) ---> 5

// memo :: [5, 5]

Then i = 2: max sum can be Math.max(memo[i - 1], arr[i] + memo[i - 2]), which is memo[2] = Math.max(5, 1 +5) --> 6:

// memo :: [5, 5, 6]

Then i = 3, should follow i = 2 partten:

// memo :: [5, 5, 6, 10]

So now, we got our partten:

for i =  to length
    memo[i] = Math.max(memo[i - ], memo[i - ] + arr[i])

Code:

function maxNonAdjSum(arr) {
  const memo = new Array(arr.length).fill();
  memo[] = Math.max(, arr[]);
  memo[] = Math.max(arr[], memo[]);
 
  for (let i = ; i < arr.length; i++) {
    memo[i] = Math.max(memo[i-], arr[i] + memo[i - ]);
  }
 
  return memo;
}
 
console.log(maxNonAdjSum([, , , , ])); //
console.log(maxNonAdjSum([, , , ])); // 10
console.log(maxNonAdjSum([, , , , , -, , ])); //

To improve it furuther for space, we don't really need to keep 'memo' as a whole array, we just need to remember 3 values:

// [max_inc, max_not_inc, max]

And:

max = Math.max(max + max_inc, max_not_inc)

Cdoe:

function maxNonAdjSum2(arr) {
  let max_inc = Math.max(, arr[]);
  let max_not_inc = Math.max(arr[], max_inc);
 
  let max = max_inc
  for (let i = ; i < arr.length; i++) {
    max = Math.max(arr[i] + max_inc, max_not_inc);
    max_inc = max_not_inc;
    max_not_inc = max;
  }
 
  return max;
}
 
console.log(maxNonAdjSum2([, , , , ])); //
console.log(maxNonAdjSum2([, , , ])); //
console.log(maxNonAdjSum2([, , , , , -, , ])); //