Minimum Cut (Stoer-Wagner) - Problem

Given an undirected weighted graph, find the minimum cut using the Stoer-Wagner algorithm. A minimum cut is the smallest sum of edge weights that, when removed, disconnects the graph into two components.

The graph is represented as an adjacency matrix where graph[i][j] represents the weight of the edge between vertices i and j. If there's no edge, the value is 0.

Return the weight of the minimum cut.

Input & Output

Example 1 — Simple Triangle Graph

$ Input: graph = [[0,2,1],[2,0,1],[1,1,0]]

› Output: 1

💡 Note: The graph forms a triangle with edges: 0-1 (weight 2), 0-2 (weight 1), 1-2 (weight 1). The minimum cut is 1, achieved by removing edge 0-2 or edge 1-2, separating one vertex from the other two.

Example 2 — Linear Chain

$ Input: graph = [[0,3,0,0],[3,0,2,0],[0,2,0,1],[0,0,1,0]]

› Output: 1

💡 Note: The graph forms a chain: 0-1-2-3 with weights 3,2,1. The minimum cut is 1 (edge 2-3), which separates vertex 3 from the rest of the graph.

Example 3 — Complete Graph

$ Input: graph = [[0,1,1],[1,0,1],[1,1,0]]

› Output: 2

💡 Note: Complete graph with all edge weights 1. To disconnect any vertex requires cutting 2 edges, so minimum cut is 2.

Constraints

1 ≤ graph.length ≤ 15
graph[i][j] = graph[j][i] (undirected graph)
graph[i][i] = 0 (no self-loops)
0 ≤ graph[i][j] ≤ 100

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 M Microsoft 10 a Amazon 8

The key insight is using the Stoer-Wagner algorithm's maximum adjacency search to systematically find the most tightly connected vertex pairs, which naturally reveals minimum cut candidates. Best approach is the Stoer-Wagner algorithm with Time: O(n³), Space: O(n²).

Common Approaches

✓ Brute Force - Try All Possible Cuts

⏱️ Time: O(2ⁿ × n²) Space: O(n)

Generate all possible non-empty partitions of vertices into two sets. For each partition, calculate the sum of edge weights crossing between the two sets. Return the minimum sum found.

Stoer-Wagner Algorithm

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

The Stoer-Wagner algorithm works by repeatedly finding the most tightly connected pair of vertices and using them to identify cut candidates. It systematically contracts the graph while maintaining cut information.

Brute Force - Try All Possible Cuts — Algorithm Steps

Generate all possible ways to split vertices into two non-empty sets
For each partition, sum weights of edges crossing between sets
Track and return the minimum cut weight found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Partition

Create a binary mask to divide vertices into two sets

Calculate Cut Weight

Sum weights of all edges crossing between the two sets

Track Minimum

Keep track of the smallest cut weight found so far

Code -

solution.c — C

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

int solution(int** graph, int n) {
    if (n <= 1) return 0;
    
    int minCut = INT_MAX;
    
    // Try all possible non-empty partitions
    for (int mask = 1; mask < (1 << n) - 1; mask++) {
        int cutWeight = 0;
        
        // Calculate cut weight for this partition
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                // If i and j are in different sets, add edge weight
                if (((mask >> i) & 1) != ((mask >> j) & 1)) {
                    cutWeight += graph[i][j];
                }
            }
        }
        
        if (cutWeight < minCut) {
            minCut = cutWeight;
        }
    }
    
    return minCut;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for small test cases
    int n = 0;
    for (int i = 0; line[i]; i++) {
        if (line[i] == '[' && line[i-1] != '[') n++;
    }
    
    int** graph = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        graph[i] = (int*)malloc(n * sizeof(int));
    }
    
    // Basic parsing - assumes small matrices
    char* ptr = line;
    for (int i = 0; i < n; i++) {
        while (*ptr != '[') ptr++;
        ptr++;
        for (int j = 0; j < n; j++) {
            graph[i][j] = 0;
            while (*ptr == ' ' || *ptr == ',') ptr++;
            if (*ptr >= '0' && *ptr <= '9') {
                graph[i][j] = *ptr - '0';
                ptr++;
            }
        }
    }
    
    printf("%d\n", solution(graph, n));
    
    for (int i = 0; i < n; i++) {
        free(graph[i]);
    }
    free(graph);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ × n²)

2^n possible partitions, each requiring O(n²) operations to calculate cut weight

⚠ Quadratic Growth

Space Complexity

O(n)

Only need to store current partition and track minimum cut

⚡ Linearithmic Space

8.8K Views

Medium Frequency

~35 min Avg. Time

342 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 Cut (Stoer-Wagner) - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Possible Cuts — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler