Sum of All Subset XOR Totals

To solve this problem, we will iterate through all possible subsets of the given list nums. We calculate the XOR of all elements of each subset and add it to our total sum.

For each element, we have two choices: either we include it in our current subset or we don’t. We can use a recursive function to explore these possibilities.

Here’s the Python code for this problem:

class Solution:
    def subsetXORSum(self, nums: List[int]) -> int: = 0
        def helper(i, xor):
            if i == len(nums):
       += xor
            helper(i+1, xor^nums[i])  # We include nums[i] in our subset.
            helper(i+1, xor)           # We don't include nums[i] in our subset.
        helper(0, 0)

This code starts with a XOR sum of 0 and recursively explores all possible subsets of nums. It keeps adding the XOR sum of each subset to the total variable.

The recursive function helper takes an index i and a current XOR sum xor. When i is equal to the length of nums, we know we have finished with one subset, so we add the current XOR sum to total.

Otherwise, we make two recursive calls: one where we include nums[i] in our current subset (and so we XOR it with our current sum), and one where we don’t include nums[i] in our subset (and so the current sum remains the same).

This approach covers all possible subsets because we are considering every possible inclusion/exclusion of each element in nums.


I get that we are using recursion over here. But can you please explain how we are using backtracking here? we are not undoing any changes we made . is addition of withElement and withoutElement backtracking ? I know this question might be very trivial for you, but i just started with backtracking so do let me know if i am correct or wrong.

Yes, your question is a good one. In this problem, the concept of backtracking is a bit subtle, because we are not undoing any changes explicitly like we do in some other problems. Here’s why it’s still considered a form of backtracking:

In recursive backtracking problems, we typically make a decision, then recurse on a subproblem. If the subproblem fails or if we want to explore other possibilities, we “undo” the decision we made earlier (hence the term “backtrack”) and try something else.

Here, we are indeed making a choice at each recursive call: we are choosing to either include a number in the XOR computation (helper(i+1, xor^nums[i])), or exclude it (helper(i+1, xor)). After making one of these choices, we then recurse on the remainder of the array.

The “backtracking” part is not as evident because of the nature of XOR operation: XORing a number and then XORing it again gets us back to the original number. So when we return from a recursive call where we included a number, we effectively “undo” the choice to include that number because we don’t carry that choice forward into the next recursive call. We then make the other choice (to exclude the number) and recurse again. So, the XOR operation itself is serving as the “undo” operation here.

To make it a bit clearer, let’s consider a decision path where we decide to include nums[0], exclude nums[1], and include nums[2]. The recursion and backtracking go like this:

  1. Include nums[0] in the XOR, and recurse.
  2. We are now at nums[1]. We decide to exclude it, and recurse.
  3. We are now at nums[2]. We decide to include it in the XOR, and recurse.
  4. When we backtrack from this path, we “undo” the decision to include nums[2] (by simply not carrying it forward), then “undo” the decision to exclude nums[1] (by not carrying it forward either), and finally “undo” the decision to include nums[0] (again, by not carrying it forward).

So, even though it might not look like traditional backtracking where we explicitly undo a choice, the effect is the same: we are exploring all possible combinations of choices by making a choice, recursing, and then “undoing” the choice to make a different one.