Optimize Water Distribution in a Village

Optimize Water Distribution in a Village - Problem

There are n houses in a village. We want to supply water for all the houses by building wells and laying pipes.

For each house i, we can either build a well inside it directly with cost wells[i - 1] (note the -1 due to 0-indexing), or pipe in water from another well to it.

The costs to lay pipes between houses are given by the array pipes where each pipes[j] = [house1j, house2j, costj] represents the cost to connect house1j and house2j together using a pipe. Connections are bidirectional, and there could be multiple valid connections between the same two houses with different costs.

Return the minimum total cost to supply water to all houses.

Input & Output

Example 1 — Basic Water Distribution

$ Input: n = 3, wells = [1,2,1], pipes = [[1,2,1],[2,3,1]]

› Output: 3

💡 Note: Build wells in houses 1 and 3 (cost 1+1=2), then connect house 2 to house 3 via pipe (cost 1). Total: 2+1=3.

Example 2 — All Wells Cheaper

$ Input: n = 2, wells = [1,1], pipes = [[1,2,2]]

› Output: 2

💡 Note: Building wells in both houses costs 1+1=2, which is cheaper than one well plus pipe (1+2=3).

Example 3 — Pipes More Efficient

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

› Output: 6

💡 Note: Build one well in house 1 (cost 3) and connect others via pipes (cost 1+1+1=3). Total: 6.

Constraints

1 ≤ n ≤ 10⁴
wells.length == n
0 ≤ wells[i] ≤ 10⁵
1 ≤ pipes.length ≤ 3 × 10⁴
pipes[j].length == 3
1 ≤ house1_j, house2_j ≤ n
0 ≤ cost_j ≤ 10⁵
house1_j ≠ house2_j

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Facebook 32 M Microsoft 28

The key insight is to transform this into a Minimum Spanning Tree problem by adding a virtual source node. Connect the source to each house with edge weight equal to the well cost, then find the MST. Best approach uses Kruskal's algorithm with Union-Find. Time: O(E log E), Space: O(E + n).

Common Approaches

✓ Brute Force - Try All Combinations

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

Try every possible subset of houses to build wells in, then for remaining houses, find minimum cost to connect them via pipes. This explores all 2^n possibilities.

Greedy with Virtual Source

⏱️ Time: O(E log E) Space: O(E + n)

Create a virtual source node (node 0) and connect it to each house with edge weight equal to the well cost. Then find MST of this augmented graph using Kruskal's or Prim's algorithm.

Brute Force - Try All Combinations — Algorithm Steps

Generate all subsets of houses for well placement
For each subset, calculate well costs
Find minimum cost to connect remaining houses via pipes
Return minimum total cost across all combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Create all 2^n subsets of houses for well placement

Calculate Costs

For each subset, sum well costs and pipe connection costs

Find Minimum

Track the minimum total cost across all combinations

Code -

solution.c — C

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

#define MAXN 12
#define INF (INT_MAX / 2)

int costMatrix[MAXN][MAXN];

int solution(int n, int* wells, int pipes[][3], int pipeCount) {
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            costMatrix[i][j] = INF;

    for (int i = 0; i < pipeCount; i++) {
        int a = pipes[i][0] - 1, b = pipes[i][1] - 1, c = pipes[i][2];
        if (c < costMatrix[a][b]) costMatrix[a][b] = c;
        if (c < costMatrix[b][a]) costMatrix[b][a] = c;
    }

    int minCost = INF;

    for (int mask = 1; mask < (1 << n); mask++) {
        int total = 0;

        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) total += wells[i];
        }

        int connected[MAXN] = {0};
        int minEdge[MAXN];
        for (int i = 0; i < n; i++) minEdge[i] = INF;

        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                connected[i] = 1;
                for (int j = 0; j < n; j++) {
                    if (!connected[j] && costMatrix[i][j] < minEdge[j]) {
                        minEdge[j] = costMatrix[i][j];
                    }
                }
            }
        }

        // Count remaining
        int remaining = 0;
        for (int i = 0; i < n; i++) {
            if (!(mask & (1 << i))) remaining++;
        }

        int valid = 1;

        for (int r = 0; r < remaining; r++) {
            int best = -1, bestCost = INF;
            for (int j = 0; j < n; j++) {
                if (!connected[j] && minEdge[j] < bestCost) {
                    bestCost = minEdge[j];
                    best = j;
                }
            }

            if (best == -1) { valid = 0; break; }

            total += bestCost;
            connected[best] = 1;

            for (int j = 0; j < n; j++) {
                if (!connected[j] && costMatrix[best][j] < minEdge[j]) {
                    minEdge[j] = costMatrix[best][j];
                }
            }
        }

        if (valid && total < minCost) minCost = total;
    }

    return minCost;
}

int main() {
    int n;
    scanf("%d", &n);

    int wells[MAXN];
    char c;
    scanf(" %c", &c); // [
    for (int i = 0; i < n; i++) {
        scanf("%d", &wells[i]);
        scanf(" %c", &c); // , or ]
    }

    // Read pipes line
    char line[4096];
    // consume rest of current line
    while (getchar() != '\n');
    fgets(line, sizeof(line), stdin);

    int pipes[200][3];
    int pipeCount = 0;

    // Parse [[a,b,c],[d,e,f],...]
    char* p = line;
    while (*p) {
        if (*p == '[' && *(p + 1) != '[') {
            p++;
            int vals[3], vi = 0;
            while (vi < 3) {
                while (*p && !isdigit(*p) && *p != '-') p++;
                if (!*p) break;
                vals[vi++] = atoi(p);
                while (*p && (isdigit(*p) || *p == '-')) p++;
            }
            if (vi == 3) {
                pipes[pipeCount][0] = vals[0];
                pipes[pipeCount][1] = vals[1];
                pipes[pipeCount][2] = vals[2];
                pipeCount++;
            }
        } else {
            p++;
        }
    }

    printf("%d\n", solution(n, wells, pipes, pipeCount));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n³)

2^n subsets to try, each requiring O(n³) to solve connection problem

⚠ Quadratic Growth

Space Complexity

O(n²)

Storage for adjacency matrix and subset combinations

⚠ Quadratic Space

78.5K Views

Medium Frequency

~35 min Avg. Time

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

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler