Number of Ways to Assign Edge Weights II - Practice Coding Problems

Number of Ways to Assign Edge Weights II - Problem

Array Math Dynamic Programming Bit Manipulation Tree Depth-First Search Hard

You're given an undirected tree with n nodes labeled from 1 to n, rooted at node 1. The tree structure is defined by a 2D array edges where edges[i] = [u_i, v_i] represents an edge between nodes u_i and v_i.

Initially, all edges have weight 0. Your task is to assign each edge a weight of either 1 or 2. The cost of a path between any two nodes is the sum of all edge weights along that path.

Given a 2D array queries where queries[i] = [u_i, v_i], for each query you need to determine: How many ways can you assign weights (1 or 2) to edges in the path between nodes u_i and v_i such that the total path cost is odd?

Important: For each query, only consider edges that are part of the path between the two query nodes. Return results modulo 10^9 + 7.

Input & Output

example_1.py — Basic Tree

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

› Output: [2, 2]

💡 Note: For query [1,3]: path is 1-2-3 (2 edges). We can assign weights (1,1), (1,2), (2,1), (2,2) giving sums 2,3,3,4. Exactly 2 are odd. For query [2,4]: path is 2-3-4 (2 edges), same logic gives 2 odd sums.

example_2.py — Single Edge

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

› Output: [1]

💡 Note: Path 1-2 has 1 edge. Possible weights: (1) sum=1 odd, (2) sum=2 even. So 2^(1-1) = 1 way gives odd sum.

example_3.py — Same Node Query

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

› Output: [0]

💡 Note: Query asks for path from node 1 to itself. No edges in path, so no way to get an odd sum. Answer is 0.

Constraints

2 ≤ n ≤ 10⁴
edges.length = n - 1
1 ≤ u_i, v_i ≤ n
1 ≤ queries.length ≤ 10⁴
The given edges form a valid tree

Visualization

Tap to expand

Understanding the Visualization

Build Road Network

Create adjacency list representation of the tree from given edges

Find Route

For each query, find the unique path between source and destination nodes

Apply Mathematical Formula

Use the insight that exactly 2^(k-1) configurations give odd sums for k road segments

Key Takeaway

🎯 Key Insight: The mathematical approach recognizes that exactly half of all weight combinations produce odd sums, making direct calculation possible without enumeration.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses mathematical insight: for k edges in a path, exactly 2^(k-1) weight assignments result in odd sums. This eliminates the need to generate all combinations, achieving O(Q × N) time complexity with tree traversal and modular exponentiation.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Optimization (Optimal)	O(Q × N)	O(N)	Use combinatorial math: exactly 2^(k-1) ways give odd sum for k edges
Brute Force (Try All Combinations)	O(Q × N × 2^N)	O(N)	For each query, find the path and try all 2^k weight assignments

Mathematical Optimization (Optimal) — Algorithm Steps

Build adjacency list from edges
For each query, find path between nodes using DFS
Count edges in the path (k edges)
Use mathematical formula: 2^(k-1) ways give odd sum
Return result modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Path Discovery

Find the unique path between query nodes in the tree structure

Mathematical Formula

For k edges: 2^(k-1) combinations give odd sum, 2^(k-1) give even sum

Direct Calculation

Use modular exponentiation to compute 2^(k-1) mod (10^9 + 7)

Code -

solution.c — C

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

#define MOD 1000000007

typedef struct {
    int* data;
    int size;
    int capacity;
} Vector;

Vector* createVector() {
    Vector* v = malloc(sizeof(Vector));
    v->data = malloc(sizeof(int) * 10);
    v->size = 0;
    v->capacity = 10;
    return v;
}

void pushVector(Vector* v, int val) {
    if (v->size >= v->capacity) {
        v->capacity *= 2;
        v->data = realloc(v->data, sizeof(int) * v->capacity);
    }
    v->data[v->size++] = val;
}

int findPathLength(int start, int end, Vector** graph, int parent) {
    if (start == end) return 0;
    
    for (int i = 0; i < graph[start]->size; i++) {
        int neighbor = graph[start]->data[i];
        if (neighbor != parent) {
            int result = findPathLength(neighbor, end, graph, start);
            if (result != -1) {
                return result + 1;
            }
        }
    }
    
    return -1;
}

long long powerMod(long long base, long long exp, long long mod) {
    long long result = 1;
    base = base % mod;
    while (exp > 0) {
        if (exp % 2 == 1) {
            result = (result * base) % mod;
        }
        exp = exp >> 1;
        base = (base * base) % mod;
    }
    return result;
}

int* solution(int n, int edges[][2], int edgesSize, int queries[][2], int queriesSize, int* returnSize) {
    Vector** graph = malloc(sizeof(Vector*) * (n + 1));
    for (int i = 0; i <= n; i++) {
        graph[i] = createVector();
    }
    
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        pushVector(graph[u], v);
        pushVector(graph[v], u);
    }
    
    int* result = malloc(sizeof(int) * queriesSize);
    *returnSize = queriesSize;
    
    for (int i = 0; i < queriesSize; i++) {
        int u = queries[i][0], v = queries[i][1];
        if (u == v) {
            result[i] = 0;
        } else {
            int pathEdges = findPathLength(u, v, graph, -1);
            if (pathEdges > 0) {
                result[i] = (int)powerMod(2, pathEdges - 1, MOD);
            } else {
                result[i] = 0;
            }
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(Q × N)

Q queries, each requiring O(N) path finding in the tree

✓ Linear Growth

Space Complexity

O(N)

Space for adjacency list and recursion stack

✓ Linear Space

26.1K 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

Constraints

Visualization

Related Problems

Common Approaches

Mathematical Optimization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler