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

Number of Ways to Assign Edge Weights I - Problem

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

Your task: Assign each edge a weight of either 1 or 2. Find a node x at the maximum depth from the root, then count how many ways you can assign weights to the edges on the path from node 1 to node x such that the total path cost is odd.

Key points:

Initially all edges have weight 0
You must assign weight 1 or 2 to each edge
Consider only edges in the path from root (1) to the deepest node
Return the count modulo 10^9 + 7

Input & Output

example_1.py — Basic Tree

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

› Output: 2

💡 Note: Tree structure: 1-2-4 and 1-3. Deepest node is 4. Path 1→2→4 has 2 edges. We can assign weights (1,1), (1,2), (2,1), or (2,2). Sums are 2, 3, 3, 4. Exactly 2 assignments (1,2) and (2,1) give odd sum 3.

example_2.py — Linear Tree

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

› Output: 2

💡 Note: Linear tree: 1-2-3. Deepest node is 3. Path 1→2→3 has 2 edges. Same analysis as example 1: 2^(2-1) = 2 ways give odd sums.

example_3.py — Single Node

$ Input: n = 1, edges = []

› Output: 0

💡 Note: Only one node, no edges. Path length is 0, so no way to get an odd sum.

Constraints

1 ≤ n ≤ 10⁵
edges.length = n - 1
The input represents a valid tree
1 ≤ u_i, v_i ≤ n
u_i ≠ v_i

Visualization

Tap to expand

Understanding the Visualization

Build the Tree

Create graph from edges and root at node 1

Find Deepest Path

Use DFS to find the node at maximum depth

Count Edge Assignments

Apply formula: 2^(path_length - 1) for odd sums

Key Takeaway

🎯 Key Insight: For k edges in the path to the deepest node, exactly 2^(k-1) weight assignments produce odd total costs, giving us an O(n) mathematical solution.

Asked in

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

The key insight is that for any path with k edges, exactly 2^(k-1) weight assignments result in odd sums. First find the deepest node using DFS, then apply this mathematical formula instead of trying all combinations.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Insight (Optimal)	O(n)	O(n)	Use combinatorial math: for k edges, exactly 2^(k-1) assignments give odd sums
Brute Force (Try All Combinations)	O(n + 2^k)	O(n)	Find deepest node, then try all 2^k weight assignments for the path

Mathematical Insight (Optimal) — Algorithm Steps

Build adjacency list from edges
Use DFS to find node at maximum depth
Count edges in path from root to deepest node
Apply formula: answer = 2^(k-1) mod (10^9 + 7)
Handle edge case when k = 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Path Length

DFS to find deepest node and path length k

Mathematical Insight

For k edges, exactly half of 2^k assignments give odd sums

Apply Formula

Answer = 2^(k-1) mod (10^9 + 7)

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_N 1001

int graph[MAX_N][MAX_N];
int graphSize[MAX_N];
int maxDepth = -1;

void dfs(int node, int parent, int depth) {
    if (depth > maxDepth) {
        maxDepth = depth;
    }
    
    for (int i = 0; i < graphSize[node]; i++) {
        int neighbor = graph[node][i];
        if (neighbor != parent) {
            dfs(neighbor, node, depth + 1);
        }
    }
}

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

int numberOfWaysToAssignEdgeWeights(int n, int** edges, int edgesSize, int* edgesColSize) {
    if (n == 1) return 0;
    
    // Initialize
    memset(graphSize, 0, sizeof(graphSize));
    maxDepth = -1;
    
    // Build adjacency list
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        graph[u][graphSize[u]++] = v;
        graph[v][graphSize[v]++] = u;
    }
    
    // Find deepest node
    dfs(1, -1, 0);
    
    int k = maxDepth;
    if (k == 0) return 0;
    
    // For k edges, exactly 2^(k-1) assignments give odd sums
    return powMod(2, k - 1, MOD);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) for DFS to find deepest node and extract path

✓ Linear Growth

Space Complexity

O(n)

O(n) for adjacency list and recursion stack

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~15 min Avg. Time

890 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 Insight (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler