Minimum Degree of a Connected Trio in a Graph - Problem

Graph Enumeration Hard

You are given an undirected graph. You are given an integer n which is the number of nodes in the graph and an array edges, where each edges[i] = [ui, vi] indicates that there is an undirected edge between ui and vi.

A connected trio is a set of three nodes where there is an edge between every pair of them.

The degree of a connected trio is the number of edges where one endpoint is in the trio, and the other is not.

Return the minimum degree of a connected trio in the graph, or -1 if the graph has no connected trios.

Input & Output

Example 1 — Basic Connected Trio

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

› Output: 3

💡 Note: There are exactly 3 trios: (1,2,3), (1,2,4), and (2,3,5). The trio (1,2,3) has degree 3 (node 1 connects to 4, node 2 connects to 5, node 3 connects to 6), which is minimum.

Example 2 — No Connected Trios

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

› Output: -1

💡 Note: No set of 3 nodes forms a complete triangle where every pair is connected.

Example 3 — Perfect Triangle

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

› Output: 0

💡 Note: The only trio is (1,2,3) and all three nodes only connect to each other, so external degree is 0.

Constraints

2 ≤ n ≤ 400
edges.length ≤ n * (n-1) / 2
edges[i].length == 2
1 ≤ ui, vi ≤ n
ui != vi
There are no repeated edges

Visualization

Tap to expand

Asked in

f Facebook 35 G Google 28 a Amazon 22

The key insight is that a connected trio's degree equals the sum of individual node degrees minus 6 (the internal trio edges). The optimized approach uses adjacency sets to efficiently find trios by checking common neighbors for each edge. Time: O(m × min(deg(u), deg(v))), Space: O(n + m).

Common Approaches

✓ Brute Force Triple Check

⏱️ Time: O(n³ + m) Space: O(n²)

For every combination of 3 nodes, check if all pairs are connected. If so, count external edges by checking each node's connections outside the trio.

Optimized with Adjacency Set

⏱️ Time: O(m · min(deg(u), deg(v))) Space: O(n + m)

Build adjacency sets for fast edge lookups. For each pair of connected nodes, check their common neighbors to find trios efficiently.

Brute Force Triple Check — Algorithm Steps

Generate all combinations of 3 nodes
For each trio, verify all pairs are connected
Count edges going outside the trio
Track minimum degree found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Check all possible groups of 3 nodes

Verify Connections

Ensure all pairs in trio are connected

Count External Edges

Sum degrees minus internal connections

Code -

solution.c — C

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

int solution(int n, int edges[][2], int edgeCount) {
    // Build adjacency matrix
    int** adjMatrix = (int**)calloc(n, sizeof(int*));
    for (int i = 0; i < n; i++) {
        adjMatrix[i] = (int*)calloc(n, sizeof(int));
    }
    
    int* degree = (int*)calloc(n, sizeof(int));
    
    for (int i = 0; i < edgeCount; i++) {
        int u = edges[i][0] - 1, v = edges[i][1] - 1;
        adjMatrix[u][v] = 1;
        adjMatrix[v][u] = 1;
        degree[u]++;
        degree[v]++;
    }
    
    int minDegree = INT_MAX;
    
    // Check all combinations of 3 nodes
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            for (int k = j + 1; k < n; k++) {
                // Check if i, j, k form a connected trio
                if (adjMatrix[i][j] && adjMatrix[j][k] && adjMatrix[i][k]) {
                    // Calculate degree: sum of degrees minus internal edges (6)
                    int trioDegree = degree[i] + degree[j] + degree[k] - 6;
                    if (trioDegree < minDegree) {
                        minDegree = trioDegree;
                    }
                }
            }
        }
    }
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(adjMatrix[i]);
    }
    free(adjMatrix);
    free(degree);
    
    return minDegree == INT_MAX ? -1 : minDegree;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char line[10000];
    fgets(line, sizeof(line), stdin); // consume newline
    fgets(line, sizeof(line), stdin);
    
    // Parse edges (simplified parsing)
    int edges[1000][2];
    int edgeCount = 0;
    char* ptr = line + 1; // skip '['
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            edges[edgeCount][0] = atoi(ptr);
            while (*ptr && *ptr != ',') ptr++;
            ptr++; // skip ','
            edges[edgeCount][1] = atoi(ptr);
            while (*ptr && *ptr != ']') ptr++;
            ptr++; // skip ']'
            edgeCount++;
        } else {
            ptr++;
        }
    }
    
    printf("%d\n", solution(n, edges, edgeCount));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³ + m)

Check all n³ combinations of 3 nodes, plus m edges to build adjacency

⚠ Quadratic Growth

Space Complexity

O(n²)

Adjacency matrix to store all edges

⚠ Quadratic Space

33.0K Views

Medium Frequency

~25 min Avg. Time

892 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

Minimum Degree of a Connected Trio in a Graph - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Triple Check — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler