Graph Valid Tree - Practice Coding Problems

Graph Valid Tree - Problem

Given n nodes labeled from 0 to n-1 and a list of undirected edges, determine if these edges form a valid tree.

A valid tree is a connected graph with exactly n-1 edges and no cycles. Think of it like a family tree or organizational chart - every node should be reachable from every other node, but there should be exactly one path between any two nodes.

Key Properties of a Tree:

🌳 Connected: All nodes must be reachable
🚫 Acyclic: No cycles allowed
📏 Minimal: Exactly n-1 edges (not more, not less)

Return true if the edges form a valid tree, false otherwise.

Input & Output

example_1.py — Valid Tree

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

› Output: true

💡 Note: This forms a valid tree: 5 nodes with 4 edges, fully connected with no cycles. Node 1 acts as a hub connecting to nodes 0, 2, and 4, with node 3 connected through node 2.

example_2.py — Has Cycle

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

› Output: false

💡 Note: This graph contains a cycle: 1→2→3→4→1. A valid tree cannot have cycles, so this returns false even though all nodes are connected.

example_3.py — Disconnected Components

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

› Output: false

💡 Note: This graph has two disconnected components: {0,1} and {2,3}. A valid tree must be fully connected, so this returns false.

Visualization

Tap to expand

Understanding the Visualization

Edge Count Check

A tree with n nodes must have exactly n-1 edges

Cycle Detection

Use DFS or Union-Find to detect if any cycles exist

Connectivity Check

Verify all nodes are reachable from any starting node

Key Takeaway

🎯 Key Insight: A valid tree is the minimal connected graph - exactly n-1 edges with full connectivity and zero cycles!

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

We visit each node once and examine each edge once, where n is nodes and m is edges

✓ Linear Growth

Space Complexity

O(n + m)

Space for adjacency list (O(n + m)) plus visited set (O(n)) plus recursion stack (O(n) in worst case)

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 2000
0 ≤ edges.length ≤ 5000
edges[i].length == 2
0 ≤ a_i, b_i < n
a_i ≠ b_i
No duplicate edges in the input

Asked in

G Google 42 f Facebook 38 a Amazon 31 ⊞ Microsoft 25

The optimal approach uses DFS traversal or Union-Find to validate tree properties. Key insight: a valid tree has exactly n-1 edges, is fully connected, and contains no cycles. DFS approach does cycle detection and connectivity check in O(n+m) time, while Union-Find efficiently detects cycles during edge processing.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Paths)	O(n²)	O(n + m)	Build graph and check all possible paths for cycles, then verify connectivity
Union-Find (Disjoint Set Union)	O(n + m × α(n))	O(n)	Use Union-Find to efficiently detect cycles while building connected components
DFS with Visited Set (Graph Traversal)	O(n + m)	O(n + m)	Single DFS traversal to check connectivity and detect cycles simultaneously

Brute Force (Check All Paths) — Algorithm Steps

Build adjacency list from edges
For each node, run DFS to detect cycles by checking if we can reach the same node through different paths
Run another DFS from node 0 to check if all nodes are reachable
Return true only if no cycles found AND all nodes connected

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list from edges

Check Cycles

From each node, explore all paths to detect cycles

Verify Connection

Ensure all nodes are reachable from node 0

Code -

solution.c — C

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

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

IntList* createList() {
    IntList* list = malloc(sizeof(IntList));
    list->data = malloc(sizeof(int) * 10);
    list->size = 0;
    list->capacity = 10;
    return list;
}

void addToList(IntList* list, int val) {
    if (list->size >= list->capacity) {
        list->capacity *= 2;
        list->data = realloc(list->data, sizeof(int) * list->capacity);
    }
    list->data[list->size++] = val;
}

bool validTree(int n, int** edges, int edgesSize, int* edgesColSize) {
    if (edgesSize != n - 1) return false;
    
    // Build adjacency list
    IntList** graph = malloc(sizeof(IntList*) * n);
    for (int i = 0; i < n; i++) {
        graph[i] = createList();
    }
    
    for (int i = 0; i < edgesSize; i++) {
        int a = edges[i][0], b = edges[i][1];
        addToList(graph[a], b);
        addToList(graph[b], a);
    }
    
    // Simple connectivity check using DFS
    bool* visited = calloc(n, sizeof(bool));
    int* stack = malloc(sizeof(int) * n);
    int top = 0;
    
    stack[top++] = 0;
    int visitedCount = 0;
    
    while (top > 0) {
        int node = stack[--top];
        if (visited[node]) continue;
        visited[node] = true;
        visitedCount++;
        
        for (int i = 0; i < graph[node]->size; i++) {
            int neighbor = graph[node]->data[i];
            if (!visited[neighbor]) {
                stack[top++] = neighbor;
            }
        }
    }
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(graph[i]->data);
        free(graph[i]);
    }
    free(graph);
    free(visited);
    free(stack);
    
    return visitedCount == n;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we might traverse up to n nodes to detect cycles, giving us O(n²) in the worst case

⚠ Quadratic Growth

Space Complexity

O(n + m)

Space for adjacency list (n nodes + m edges) plus recursion stack depth

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 2000
0 ≤ edges.length ≤ 5000
edges[i].length == 2
0 ≤ a_i, b_i < n
a_i ≠ b_i
No duplicate edges in the input

67.2K Views

High Frequency

~15 min Avg. Time

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

Brute Force (Check All Paths) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler