Find the Maximum Sum of Node Values - Leetcode 3068 - Python 

Thanks to you, my daily challenge streak is alive.

Thank you for the consistent speedy solutions 🙌

Wow. I couldn’t even make sense of the problem. I like your walk-through and approach to these problems. Most of these problems are not practical, useful, or relevant to front end engineering. But they are relevant to passing the interview. In 2009, I failed my google interview when I couldn’t solve “product of array except self“. You don’t even need the edges array. Wow.

Watched so many solutions. Yours was the only one that I understood.

other people videos were really confusing, you were straight to the point.. thanks!!

your approach and explanation for this question is absolutely superb, nailed it down

you can take range(1, len(nums), 2): path_delta =delta[i-1] + delta[i], and the first if isn't needed

A solution I found is O(n) time complexity and O(1) space. Basically, considering that each value is either "flipped" or "not flipped", and we need to ensure the number of "flips" we make is even (flipped in pairs of 2), that means that *at most* we will need to give up 1 of the larger values and instead take the smaller value to make it even (we can take ALL the larger values if the flips are even). Obviously, we'll want to flip back the value that has the smallest difference between being XORed vs not XORed. So, we go through the values, tracking these pieces of information: the total sum of all values (adding greedily whichever value is larger, XOR or not XOR), a boolean value `oddFlips` which starts as false and toggles every time we add an XOR value to the sum, and then absolute value of the smallest difference between the XOR and not XORed value. Then, at the end, if we have an odd number of flips, we just subtract that smallest difference to effectively "flip back" that node to remove the extra value it gave.

love your videos mann!!! you make them look so easy. thank you!!

I really liked the thought process you explained in this video. Thank you for the effort!

After I watched your second hint, this question became a piece of cake. Thx

yeah you helped me solve the problem by giving hints. Thanks :)

Great explanation as always. Thanks for your efforts

Bro your way of teaching and the way you solve the problems are really good 🔥

The one nitpick I have with your code is the first break statement. instead, loop through len(nums) -1. Thank you.

Speechless superb approach thank you so much

Brilliant explanation!

Thanks for the simple and concise explanation, If possible can you share the O(n) approach which you mentioned existed for this problem?

I just came up with O(2^n ) Solution . But I was able to notice this XOR property . Thanks NeetCode for your efforts.

Instead of sorting, we can keep track of sum_of_delta, count_of_delta, min_delta for delta >= 0, max_neg_delta for delta < 0. Now if count is even then answer is sum(nums)+sum_delta else we need to either remove the min delta or add a neg delta from delta < 0. answer looks something like this sum(nums)+sum_delta+ max(-min_delta,max_neg_delta). This will be O(n)

You are the best, hands down 🙌

I find it difficult to convince myself that this works, but then sorting can be eliminated easily: count number of positive deltas; if you have even number of them then take all of them, otherwise take all but the min positive delta; then decide whether to include or discard min positive and max non-positive delta (if it exists) pair. So you need to track number of positive deltas, min positive delta and max non-positive delta values - no sorting required. This also eliminates need for delta[] array.

Thanks Beats 100 % by time and Memory, if odd changes where made think of minimum impact value and take XOR on that value count = 0 small_impact = None for x in range(len(nums)): if (nums[x] ^ k) > nums[x]: nums[x] = nums[x] ^ k count += 1 if small_impact is None: small_impact = x else: if (nums[x] - (nums[x] ^ k)) < (nums[small_impact] - (nums[small_impact] ^ k)): small_impact = x if count%2 == 0: return sum(nums) else: nums[small_impact] = nums[small_impact] ^ k return sum(nums)

Nice Problem, I wonder if a similar question where we xor and sum the actual values of the nodes (the indexes) rather than the numbers in the "nums" array would have a more efficient solution (because all the values are sorted from 0 to n-1). Also, can't you get an O(n) solution easily by just doing XOR on all the values that will increase from it and saving the smallest difference caused by this action (or caused by not doing this action) in a variable, and if the final amount of XOR operations is odd subtracting that amount from the total sum?

Nice approach 🎉

Brilliant! Save my day!

I'm pretty sure that problem's description says that we can only peek two nodes that have EDGE between them, not a PATH. And you don't use "edges" array in your soltion. But your solutions works and that's what matters) Thanks!

Gah, I was so close to figuring this out on my own. Thank you so much for the explanation, it saved me many hours of banging my head against the wall!

man you make hard problems easy!

O(n) solution, XOR all the numbers that needs to be XOR'ed to increase the total value, if we XOR'ed even times, all is good and we can return sum of all the numbers. If we XOR'ed odd times, we need to XOR one number back to its lower value. So we XOR the number which has the smallest delta (absolute difference) with its XOR'ed value, then update the result accordingly. class Solution: def maximumValueSum(self, nums: List[int], k: int, edges: List[List[int]]) -> int: bad = 0 # no.of bad nodes. bad nodes == nodes who should be XOR'ed to increase its value res = 0 smallest_diff = [float('inf'),None] # [ diff, index ] to keep track of which node has the smallest delta for i,n in enumerate(nums): diff = (n^k) - n if smallest_diff[0] > abs(diff): smallest_diff = [abs(diff),i] if diff > 0: nums[i] = n^k bad += 1 res += nums[i] if bad%2: # if odd no.of bad nodes, we must leave 1 bad node. if even, we can convert all to good nodes res = res - nums[smallest_diff[1]] + (nums[smallest_diff[1]]^k) return res

Nice explanation. It's really strange that this problem can be found without using the edges argument.

My mentor!

Bro you are great!

you can iterate till len(nums) - 1, instead of writing this if and break in the for loop

beautiful problem

brilliant

Hey, I was wondering if someone could explain the expected value for the following test case? nums = [78,43,92,97,95,94], k= 6 and edges = [[1,2],[3,0],[4,0],[0,1],[1,5]] I am getting the value as 499, as no edges can be selected to increase the sum of values in nums post operations.

You deserve more reach❤ but kindly slow down a bit😅

thank you :-)

12:03 that looks more like amongus

I simply used a heap to achieve a time complexity of O(n) although my solution was slower than yours XD

Neetcode saved me from unemployment

Please explain leetcode 3143 - asked in contest

i have little bit confusion in the for loop why we can iterate through step if we do normally add the elements we get maximum that this and i experience this nums = [24,78,1,97,44] k = 6 edges = [[0,2],[1,2],[4,2],[3,4]] Use Testcase Output 262 Expected 260 could you explain this why we put for loop like this....

You didn't even use the edge parameter at all. Could that have been useful to make the approach more efficient?

I couldn't solve anything for this problem. But at least I did the O(n) solution: solution in rust impl Solution { pub fn maximum_value_sum(nums: Vec, k: i32, _edges: Vec) -> i64 { let mut sum = 0; let mut max_negative = i32::MIN; let mut min_positive = i32::MAX; let mut count_positives = 0; for num in nums { let delta = (num ^ k) - num; if delta.is_positive() { count_positives += 1; min_positive = min_positive.min(delta); } else { max_negative = max_negative.max(delta); } sum += if delta.is_positive() { num + delta } else { num } as i64; } if count_positives % 2 != 0 { if min_positive + max_negative > 0 { sum += max_negative as i64; } else { sum -= min_positive as i64; } } sum } }

edges array be like : Am i a joke to you ??? 😡 after left unused in the nlogn solution. 😅

First🎉🎉

At 12.45 mark, why are we picking 2 values at a time? Any logic behind that?

They said not to do it twice! Say wht? Screw it