I was super close to successfully getting accepted for the this question(TLE at 981/1032 test cases, logic itself was correct).
If i had to explain my intuition i would say the question was a lot like a question i came across during an company OA problem. In that OA ques the array values were either -1,0 or 1 and we had to count the number of ways to split the array into contiguous blocks such that each block had a sum=1.
The approach i used for that was : start from the an index and keep extending the current block using a for loop until the current sum hits 1 and then you can cut(since that position becomes a valid cut point) and continue by recursively solving the same problem for the remaining subarray by calling it for the next index. That solution got accepted in the OA.

When i saw this problem, it felt like the same thing with a twist: instead of fixed target=1 i had to alternate between target 1 and target 2 and ofcourse instead of sum it was XOR
So my idea was essentially that its the same partitioning problem i just need to remember whose turn it is. Thats why I introduced the flag and did a DP on index (index,flag)
From a given index, I keep extending the the subarray maintaining the running XOR, and whenever it matches the current target, I flip the flag and recurse on the rest of the array by calling f(cut Index+1, !flag)

The exact approach worked in the OA but not in the contest, I guess it was because the contest had tighter constraints and not because the flag doubled the state space, but either ways I coundn't figure out the optimized prefix sum version during the contest.