Minimum Degree of a Connected Trio in a Graph

Minimum Degree of a Connected Trio in a Graph - Problem

Graph Enumeration Hard

You're given an undirected graph with n nodes and a list of edges. Your task is to find a special formation called a "connected trio" and determine which one has the minimum degree.

What is a Connected Trio?
A connected trio is a group of three nodes where every pair is directly connected by an edge. Think of it as a triangle in the graph - nodes A, B, and C form a trio if there are edges A-B, B-C, and A-C.

What is the Degree of a Trio?
The degree of a connected trio is the count of external edges - edges that have one endpoint inside the trio and the other endpoint outside the trio. Internal edges within the trio don't count!

Goal: Return the minimum degree among all connected trios in the graph, or -1 if no connected trio exists.

Example: If trio {1,2,3} has external connections to nodes 4,5,6,7, and the total external edges are 5, then this trio's degree is 5.

Input & Output

example_1.py — Basic Triangle

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

› Output: 3

💡 Note: There is exactly one trio: [1,2,3]. The degree is 3+4+2-6=3 (node 1 connects to 4, node 2 connects to 5, node 3 connects to 6, minus 6 internal connections)

example_2.py — Multiple Triangles

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

› Output: 0

💡 Note: Triangle [5,6,7] has degree 2+3+2-6=1, and triangle [2,5,6] has degree 2+3+3-6=2. But there's actually a triangle with degree 0 possible

example_3.py — No Triangle

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

› Output: -1

💡 Note: This is a simple path graph with no triangles, so no connected trio exists

Visualization

Tap to expand

Understanding the Visualization

Identify Triangles

Find groups of 3 people who are all mutual friends

Count External Friends

For each trio, count their connections to people outside the group

Find Minimum

The trio with the least external connections is most tight-knit

Key Takeaway

🎯 Key Insight: Use edge-based triangle detection with pre-calculated degrees to efficiently find the minimum degree connected trio without checking all possible triplets

Time & Space Complexity

Time Complexity

⏱️

O(m√m)

For each edge, check intersection of two adjacency lists. In dense graphs, this approaches O(m√m)

✓ Linear Growth

Space Complexity

O(n + m)

Space for adjacency lists and degree arrays

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 400
edges[i].length == 2
1 ≤ edges.length ≤ n * (n-1) / 2
1 ≤ u_i, v_i ≤ n
u_i ≠ v_i
No repeated edges in the input

Asked in

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

The optimal approach uses edge-based triangle detection with pre-calculated degrees. For each edge (u,v), find common neighbors to form triangles, then calculate trio degree as degree[u] + degree[v] + degree[w] - 6. This avoids the O(n³) brute force approach and achieves O(m√m) complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Graph Traversal	O(m√m)	O(n + m)	Use adjacency list with degree pre-calculation for efficient trio detection
Brute Force (Check All Triplets)	O(n³)	O(n + m)	Check every possible triplet of nodes for trio formation and count external edges

Optimized Graph Traversal — Algorithm Steps

Build adjacency list and calculate degrees for each node
For each edge (u,v), find common neighbors of u and v
Each common neighbor w forms trio (u,v,w)
Calculate trio degree as degree[u] + degree[v] + degree[w] - 6
Track minimum degree found

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list and pre-calculate all node degrees

Edge-Based Search

For each edge (u,v), find nodes connected to both u and v

Triangle Found

Common neighbor w creates triangle (u,v,w)

Calculate Degree

Sum: degree[u] + degree[v] + degree[w] - 6

Code -

solution.c — C

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

int minTrioDegree(int n, int** edges, int edgesSize) {
    // Build adjacency matrix and calculate degrees
    int** adj = (int**)calloc(n + 1, sizeof(int*));
    int* degrees = (int*)calloc(n + 1, sizeof(int));
    
    for (int i = 1; i <= n; i++) {
        adj[i] = (int*)calloc(n + 1, sizeof(int));
    }
    
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        adj[u][v] = adj[v][u] = 1;
        degrees[u]++;
        degrees[v]++;
    }
    
    int minDegree = INT_MAX;
    
    // For each edge, find triangles
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        // Find common neighbors of u and v
        for (int w = 1; w <= n; w++) {
            if (adj[u][w] && adj[v][w] && w != u && w != v) {
                // Triangle found: u, v, w
                int trioDegree = degrees[u] + degrees[v] + degrees[w] - 6;
                if (trioDegree < minDegree) {
                    minDegree = trioDegree;
                }
            }
        }
    }
    
    // Cleanup
    for (int i = 1; i <= n; i++) {
        free(adj[i]);
    }
    free(adj);
    free(degrees);
    
    return minDegree == INT_MAX ? -1 : minDegree;
}

int main() {
    printf("-1\n"); // Placeholder
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m√m)

For each edge, check intersection of two adjacency lists. In dense graphs, this approaches O(m√m)

✓ Linear Growth

Space Complexity

O(n + m)

Space for adjacency lists and degree arrays

⚡ Linearithmic Space

Constraints

2 ≤ n ≤ 400
edges[i].length == 2
1 ≤ edges.length ≤ n * (n-1) / 2
1 ≤ u_i, v_i ≤ n
u_i ≠ v_i
No repeated edges in the input

48.0K Views

Medium-High Frequency

~25 min Avg. Time

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

Optimized Graph Traversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler