Add Edges to Make Degrees of All Nodes Even

Add Edges to Make Degrees of All Nodes Even - Problem

Graph Degree Balancing Challenge

You're given an undirected graph with n nodes numbered from 1 to n, and a set of edges connecting some of these nodes. The graph might be disconnected, meaning some nodes might not be reachable from others.

Your mission is to determine if you can make every node have an even degree by adding at most 2 additional edges. The degree of a node is simply the number of edges connected to it.

Rules:
• You can add 0, 1, or 2 edges maximum
• No duplicate edges allowed
• No self-loops (a node cannot connect to itself)

Goal: Return true if it's possible to make all node degrees even, false otherwise.

This problem tests your understanding of graph theory and the fundamental properties of graph connectivity.

Input & Output

example_1.py — Basic Case

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

› Output: true

💡 Note: Node degrees: [2,4,3,1]. Nodes 3 and 4 have odd degrees. We can add edge (3,4) to make all degrees even: [2,4,4,2].

example_2.py — Impossible Case

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

› Output: false

💡 Note: All 4 nodes have degree 1 (odd). We'd need to add edges to pair them up, but we can only add 2 edges maximum. No way to make all 4 degrees even with just 2 additional edges.

example_3.py — Already Balanced

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

› Output: true

💡 Note: All nodes already have degree 2 (even). No additional edges needed.

Visualization

Tap to expand

Understanding the Visualization

Count Handshakes

Each person counts how many hands they've shaken (degree calculation)

Find Odd Counts

Identify people with odd handshake counts (odd-degree vertices)

Strategic Pairing

Plan additional handshakes to make everyone's count even

Key Takeaway

🎯 Key Insight: In any graph, the number of odd-degree vertices is always even due to the handshaking lemma. We just need to pair them up efficiently using at most 2 edges!

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Single pass through edges O(m) plus checking nodes O(n), where m is number of edges

✓ Linear Growth

Space Complexity

O(n + m)

Store degree array O(n) and edge set O(m) for duplicate checking

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁵
0 ≤ edges.length ≤ min(2 * 10⁵, n * (n-1) / 2)
edges[i].length == 2
1 ≤ a_i, b_i ≤ n
a_i != b_i
There are no repeated edges

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

This problem requires understanding a fundamental graph theory property: the number of odd-degree vertices in any graph is always even. The optimal approach identifies odd-degree vertices and checks if they can be paired using at most 2 additional edges. For 2 odd vertices, try direct connection or connection via an even-degree intermediate. For 4 odd vertices, try all 3 possible pairings. Time complexity: O(n + m).

Common Approaches

Approach	Time	Space	Notes
✓ Graph Theory Optimal Solution	O(n + m)	O(n + m)	Use mathematical properties of graphs to efficiently determine if balancing is possible
Brute Force (Try All Edge Combinations)	O(n⁴)	O(n)	Try adding every possible combination of 0, 1, or 2 edges and check if all degrees become even

Graph Theory Optimal Solution — Algorithm Steps

Count the degree of each vertex and track existing edges
Collect all vertices with odd degrees
Apply graph theory: if odd-degree count is not 0, 2, or 4, return false
For 2 odd vertices: check if we can connect them directly or through an even-degree vertex
For 4 odd vertices: check if we can pair them with 2 edges in any valid way
Return the result based on feasible edge additions

Visualization

Tap to expand

Step-by-Step Walkthrough

Graph Theory Insight

Number of odd-degree vertices is always even

Case Analysis

Handle 0, 2, or 4 odd vertices systematically

Smart Pairing

Check feasible ways to pair odd vertices

Code -

solution.c — C

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

#define MAX_KEY_LEN 20

typedef struct EdgeNode {
    char key[MAX_KEY_LEN];
    struct EdgeNode* next;
} EdgeNode;

typedef struct {
    EdgeNode* buckets[10007];
} EdgeSet;

int hash(const char* key) {
    int h = 0;
    for (int i = 0; key[i]; i++) {
        h = (h * 31 + key[i]) % 10007;
    }
    return h;
}

bool contains(EdgeSet* set, const char* key) {
    int h = hash(key);
    EdgeNode* node = set->buckets[h];
    while (node) {
        if (strcmp(node->key, key) == 0) return true;
        node = node->next;
    }
    return false;
}

void insert(EdgeSet* set, const char* key) {
    int h = hash(key);
    EdgeNode* node = malloc(sizeof(EdgeNode));
    strcpy(node->key, key);
    node->next = set->buckets[h];
    set->buckets[h] = node;
}

bool isPossible(int n, int** edges, int edgesSize, int* edgesColSize) {
    int* degree = calloc(n + 1, sizeof(int));
    EdgeSet edgeSet = {0};
    
    // Build degree count and edge set
    for (int i = 0; i < edgesSize; i++) {
        int a = edges[i][0], b = edges[i][1];
        degree[a]++;
        degree[b]++;
        
        char key[MAX_KEY_LEN];
        if (a < b) {
            sprintf(key, "%d-%d", a, b);
        } else {
            sprintf(key, "%d-%d", b, a);
        }
        insert(&edgeSet, key);
    }
    
    // Find odd degree nodes
    int oddNodes[n + 1];
    int oddCount = 0;
    for (int i = 1; i <= n; i++) {
        if (degree[i] % 2 == 1) {
            oddNodes[oddCount++] = i;
        }
    }
    
    bool hasEdge(int u, int v) {
        char key[MAX_KEY_LEN];
        if (u < v) {
            sprintf(key, "%d-%d", u, v);
        } else {
            sprintf(key, "%d-%d", v, u);
        }
        return contains(&edgeSet, key);
    }
    
    bool result = false;
    
    if (oddCount == 0) {
        result = true;
    } else if (oddCount == 2) {
        int u = oddNodes[0], v = oddNodes[1];
        if (!hasEdge(u, v)) {
            result = true;
        } else {
            // Check through intermediate even-degree node
            for (int w = 1; w <= n && !result; w++) {
                if (w != u && w != v && degree[w] % 2 == 0) {
                    if (!hasEdge(u, w) && !hasEdge(v, w)) {
                        result = true;
                    }
                }
            }
        }
    } else if (oddCount == 4) {
        int a = oddNodes[0], b = oddNodes[1];
        int c = oddNodes[2], d = oddNodes[3];
        
        // Try all three pairings
        result = (!hasEdge(a, b) && !hasEdge(c, d)) ||
                 (!hasEdge(a, c) && !hasEdge(b, d)) ||
                 (!hasEdge(a, d) && !hasEdge(b, c));
    }
    
    // Cleanup
    for (int i = 0; i < 10007; i++) {
        EdgeNode* node = edgeSet.buckets[i];
        while (node) {
            EdgeNode* temp = node;
            node = node->next;
            free(temp);
        }
    }
    free(degree);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Single pass through edges O(m) plus checking nodes O(n), where m is number of edges

✓ Linear Growth

Space Complexity

O(n + m)

Store degree array O(n) and edge set O(m) for duplicate checking

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁵
0 ≤ edges.length ≤ min(2 * 10⁵, n * (n-1) / 2)
edges[i].length == 2
1 ≤ a_i, b_i ≤ n
a_i != b_i
There are no repeated edges

41.2K Views

Medium-High Frequency

~25 min Avg. Time

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

Graph Theory Optimal Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler