Minimum Cost to Connect Two Groups of Points

Minimum Cost to Connect Two Groups of Points - Problem

Minimum Cost to Connect Two Groups of Points

Imagine you're a network engineer tasked with connecting two cities through multiple connection points. You have two groups of points where Group A has size1 points and Group B has size2 points, with the constraint that size1 >= size2.

The connection cost between any two points is given in a size1 x size2 matrix where cost[i][j] represents the cost of connecting point i from Group A to point j from Group B.

The Challenge: Both groups must be fully connected, meaning:
• Every point in Group A must connect to at least one point in Group B
• Every point in Group B must connect to at least one point in Group A

Your goal is to find the minimum total cost to achieve this complete connectivity between both groups.

Input & Output

example_1.py — Basic Connection

$ Input: cost = [[15,96],[36,2]]

› Output: 17

💡 Note: Connect A1 to B2 (cost 96) and A2 to B2 (cost 2), then connect B1 to A2 (cost 36) since B1 must be connected. Wait, let me recalculate: Connect A1 to B2 (cost 96) and A2 to both B1 (cost 36) and B2 (cost 2). Total cost = 96 + 36 + 2 = 134. Actually, the optimal is: A1→B2 (96), A2→B1 (36), but B2 needs connection, so A2→B2 (2). Minimum cost is A1→B2 (96) and A2→B1 (36), but we need B2 connected, so add cheapest connection to B2 which is A2→B2 (2). Wait, optimal is: A1→B1 (15) and A2→B2 (2) = 17.

example_2.py — Multiple Connections

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

› Output: 4

💡 Note: Connect A1→B1 (1), A2→B3 (1), A3→B1 (1). Now B2 needs connection, cheapest is A2→B2 (1). Total: 1+1+1+1=4.

example_3.py — Edge Case

$ Input: cost = [[2,1],[1,4]]

› Output: 4

💡 Note: Must connect all points. Connect A1→B2 (1), A2→B1 (1), but now need A1 connected to B1 (2). Total minimum cost is 4.

Constraints

size1 == cost.length
size2 == cost[i].length
1 ≤ size2 ≤ size1 ≤ 12
size1 ≥ size2
0 ≤ cost[i][j] ≤ 100

Visualization

Tap to expand

Understanding the Visualization

Identify Groups

Building A (larger) has more floors than Building B (smaller)

Track Connections

Use bitmasks to efficiently track which floors in Building B are connected

Dynamic Planning

For each floor in Building A, determine optimal connections to Building B

Complete Network

Ensure all floors in both buildings have network connectivity

Key Takeaway

🎯 Key Insight: Use bitmasks to represent connection states of the smaller group, enabling efficient dynamic programming solution

Asked in

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

This problem requires dynamic programming with bitmasks to efficiently track connections between groups. The optimal approach uses a DP state where dp[i][mask] represents the minimum cost to connect the first i points of Group A with Group B points represented by the bitmask. Key insight: since Group B is smaller, we can use bitmasks to represent all possible connection states efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Bitmask (Optimal)	O(size1 × 3^size2)	O(size1 × 2^size2)	Use DP with bitmask to track second group connections efficiently
Brute Force (Exponential Search)	O(2^(size1 * size2))	O(2^(size1 * size2))	Try all possible connection combinations

Dynamic Programming with Bitmask (Optimal) — Algorithm Steps

Create DP table where dp[i][mask] = minimum cost to connect first i points of Group A with Group B points represented by mask
For each point in Group A, try connecting to each subset of Group B points
Update the bitmask to reflect newly connected points in Group B
After processing all Group A points, ensure all Group B points are connected

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP State

Create DP table where each state tracks Group B connections

Process Group A Points

For each point in Group A, try all connection subsets to Group B

Update Bitmask

Update the bitmask to reflect new Group B connections

Complete Connections

Ensure all Group B points are connected using precomputed costs

Code -

solution.c — C

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

int connectTwoGroups(int** cost, int size1, int size2) {
    // Precompute minimum cost for each subset of group 2
    int* minCost = malloc((1 << size2) * sizeof(int));
    for (int i = 0; i < (1 << size2); i++) {
        minCost[i] = INT_MAX;
    }
    minCost[0] = 0;
    
    for (int mask = 0; mask < (1 << size2); mask++) {
        for (int j = 0; j < size2; j++) {
            if (mask & (1 << j)) {
                int prevMask = mask ^ (1 << j);
                int minFromGroup1 = INT_MAX;
                for (int i = 0; i < size1; i++) {
                    if (cost[i][j] < minFromGroup1) {
                        minFromGroup1 = cost[i][j];
                    }
                }
                if (minCost[prevMask] != INT_MAX) {
                    int newCost = minCost[prevMask] + minFromGroup1;
                    if (newCost < minCost[mask]) {
                        minCost[mask] = newCost;
                    }
                }
            }
        }
    }
    
    // DP table
    int** dp = malloc((size1 + 1) * sizeof(int*));
    for (int i = 0; i <= size1; i++) {
        dp[i] = malloc((1 << size2) * sizeof(int));
        for (int j = 0; j < (1 << size2); j++) {
            dp[i][j] = INT_MAX;
        }
    }
    dp[0][0] = 0;
    
    for (int i = 0; i < size1; i++) {
        for (int mask = 0; mask < (1 << size2); mask++) {
            if (dp[i][mask] == INT_MAX) continue;
            
            for (int submask = 1; submask < (1 << size2); submask++) {
                int costToAdd = 0;
                for (int j = 0; j < size2; j++) {
                    if (submask & (1 << j)) {
                        costToAdd += cost[i][j];
                    }
                }
                
                int newMask = mask | submask;
                int newCost = dp[i][mask] + costToAdd;
                if (newCost < dp[i + 1][newMask]) {
                    dp[i + 1][newMask] = newCost;
                }
            }
        }
    }
    
    int result = INT_MAX;
    int fullMask = (1 << size2) - 1;
    
    for (int mask = 0; mask < (1 << size2); mask++) {
        if (dp[size1][mask] != INT_MAX) {
            int missingMask = fullMask ^ mask;
            int totalCost = dp[size1][mask] + minCost[missingMask];
            if (totalCost < result) {
                result = totalCost;
            }
        }
    }
    
    // Clean up
    free(minCost);
    for (int i = 0; i <= size1; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(size1 × 3^size2)

For each of size1 points, we iterate through all 2^size2 masks and for each mask we consider 2^size2 submasks

✓ Linear Growth

Space Complexity

O(size1 × 2^size2)

DP table stores states for all combinations of Group A points and Group B connection masks

✓ Linear Space

23.5K Views

Medium Frequency

~35 min Avg. Time

890 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

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming with Bitmask (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler