Number of Nodes With Value One - Practice Coding Problems

Number of Nodes With Value One - Problem

Imagine you have a special binary-like tree where nodes follow a unique parent-child relationship! 🌳

Given an integer n, you automatically get a tree with nodes labeled from 1 to n. The magic rule is: every node v has a parent at position floor(v/2), making node 1 the root.

For example, if n = 7:

Node 3's parent is floor(3/2) = 1
Node 7's parent is floor(7/2) = 3
Node 6's parent is floor(6/2) = 3

Initially, all nodes have value 0. You're given an array queries where each query flips all values in a node's entire subtree (0 becomes 1, 1 becomes 0).

Goal: Return the total count of nodes with value 1 after processing all queries.

Input & Output

example_1.py — Basic Tree

$ Input: n = 7, queries = [1, 3, 2, 5]

› Output: 6

💡 Note: Query 1 flips all nodes (1-7). Query 3 flips nodes 3,6,7. Query 2 flips nodes 2,4,5. Query 5 flips only node 5. Final state: nodes 1,2,3,4,6,7 have value 1.

example_2.py — Small Tree

$ Input: n = 3, queries = [2, 3, 1]

› Output: 1

💡 Note: Query 2 flips node 2. Query 3 flips node 3. Query 1 flips all nodes 1,2,3. Final: only node 1 has value 1.

example_3.py — Single Node

$ Input: n = 1, queries = [1, 1, 1]

› Output: 1

💡 Note: Node 1 is flipped 3 times (odd), so final value is 1. Result: 1 node with value 1.

Visualization

Tap to expand

Understanding the Visualization

Tree Structure

Build tree using parent rule: parent of v = floor(v/2)

Query Processing

Each query flips a node and its entire subtree

Flip Counting

Count total flips per node instead of simulating each one

Final State

Node value = flip_count % 2, count nodes with value 1

Key Takeaway

🎯 Key Insight: Instead of simulating each flip, count how many times each node gets flipped. Final value = flip_count % 2. This mathematical approach avoids redundant operations and makes the solution more intuitive.

Time & Space Complexity

Time Complexity

⏱️

O(q × n)

Still need to process all descendants for each query

✓ Linear Growth

Space Complexity

O(n)

Array to store flip count for each node

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁵
1 ≤ queries.length ≤ 10⁵
1 ≤ queries[i] ≤ n
Tree structure: parent of node v is floor(v/2), root is node 1

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal approach uses flip counting instead of simulating each flip operation. Key insight: a node has value 1 if flipped an odd number of times, 0 if flipped an even number of times. While still O(q × n) in worst case, this avoids redundant state changes and provides cleaner logic for understanding the final tree state.

Common Approaches

Approach	Time	Space	Notes
✓ Flip Counter Optimization (Optimal)	O(q × n)	O(n)	Count flips per node, determine final state based on odd/even count
Brute Force (Simulate Each Query)	O(q × n)	O(n)	For each query, find all nodes in subtree and flip their values

Flip Counter Optimization (Optimal) — Algorithm Steps

Create flip counter array for all nodes
For each query, increment flip count for query node and all descendants
Final value of each node = flip_count % 2
Count nodes where final value is 1

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Counters

Create flip counter array, all start at 0

Process Query 1

Increment flip count for node 1 and all descendants

Process Query 3

Increment flip count for node 3 and its descendants

Calculate Final State

Node value = flip_count % 2, count nodes with value 1

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

void addFlipsToSubtree(int node, int n, int* flipCount) {
    flipCount[node]++;
    
    int left = 2 * node;
    int right = 2 * node + 1;
    
    if (left <= n) addFlipsToSubtree(left, n, flipCount);
    if (right <= n) addFlipsToSubtree(right, n, flipCount);
}

int numberOfNodesWithValueOne(int n, int* queries, int queriesSize) {
    int* flipCount = (int*)calloc(n + 1, sizeof(int));
    
    for (int i = 0; i < queriesSize; i++) {
        addFlipsToSubtree(queries[i], n, flipCount);
    }
    
    int count = 0;
    for (int i = 1; i <= n; i++) {
        if (flipCount[i] % 2 == 1) count++;
    }
    
    free(flipCount);
    return count;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(q × n)

Still need to process all descendants for each query

✓ Linear Growth

Space Complexity

O(n)

Array to store flip count for each node

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁵
1 ≤ queries.length ≤ 10⁵
1 ≤ queries[i] ≤ n
Tree structure: parent of node v is floor(v/2), root is node 1

28.5K Views

Medium Frequency

~25 min Avg. Time

847 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Flip Counter Optimization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler