Optimize Water Distribution in a Village - Practice Coding Problems

Optimize Water Distribution in a Village - Problem

You are tasked with designing an optimal water distribution system for a village with n houses. To ensure every house has access to water, you have two options for each house:

Build a well directly inside the house at cost wells[i-1] for house i
Connect to another well via pipes with costs specified in the pipes array

The pipes array contains entries [house1, house2, cost] representing the cost to connect two houses bidirectionally. Multiple connections between the same houses are possible with different costs.

Goal: Find the minimum total cost to supply water to all houses in the village.

This is a classic Minimum Spanning Tree problem with a twist - we can add virtual wells!

Input & Output

example_1.py — Basic village with 3 houses

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

› Output: 3

💡 Note: Optimal: Build well at house 1 (cost 1), connect house 2 to house 1 via pipe (cost 1), connect house 3 to house 2 via pipe (cost 1). Total cost = 1 + 1 + 1 = 3.

example_2.py — Expensive pipes scenario

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

› Output: 2

💡 Note: Building wells in both houses costs 1 + 1 = 2, while connecting via pipe would cost min(1) + 2 = 3. Better to build individual wells.

example_3.py — Large village optimization

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

› Output: 7

💡 Note: Build well at house 1 (cost 3), connect houses 2, 3, 4 via minimum cost pipes: 1-2 (cost 2), 1-3 (cost 2). Total = 3 + 2 + 2 = 7.

Time & Space Complexity

Time Complexity

⏱️

O((m+n) log(m+n))

Sorting (m+n) edges takes O((m+n) log(m+n)), Union-Find operations are nearly O(1) with path compression

⚡ Linearithmic

Space Complexity

O(m+n)

Space for storing edges, Union-Find parent array, and rank array

⚡ Linearithmic Space

Constraints

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

Asked in

The optimal solution uses Minimum Spanning Tree with Virtual Source. By adding a virtual source connected to all houses with well costs as edge weights, we transform the problem into finding the MST using Kruskal's algorithm with Union-Find. This elegant approach achieves O((m+n) log(m+n)) time complexity and guarantees the minimum cost water distribution.

Common Approaches

Approach	Time	Space	Notes
✓ Minimum Spanning Tree with Virtual Source (Optimal)	O((m+n) log(m+n))	O(m+n)	Transform to MST problem by adding virtual source connected to all houses with well costs
Brute Force (Try All Combinations)	O(2^n × n²)	O(n)	Try all possible combinations of wells and pipe connections

Minimum Spanning Tree with Virtual Source (Optimal) — Algorithm Steps

Create a virtual source node (node 0)
Add edges from virtual source to each house with well costs
Add all pipe connections as edges between houses
Sort all edges by cost (both well and pipe edges)
Use Kruskal's algorithm with Union-Find to build MST
Return total cost of MST edges

Visualization

Tap to expand

Step-by-Step Walkthrough

Add Virtual Source

Create node 0 connected to all houses with well costs

Combine All Edges

Merge virtual source edges with pipe edges

Sort by Cost

Sort all edges by cost for Kruskal's algorithm

Build MST

Use Union-Find to select minimum cost edges without cycles

Optimal Solution

MST gives minimum cost to connect all houses to water

Code -

solution.c — C

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

typedef struct {
    int cost, u, v;
} Edge;

int compare(const void *a, const void *b) {
    return ((Edge*)a)->cost - ((Edge*)b)->cost;
}

int find(int parent[], int x) {
    if (parent[x] != x) {
        parent[x] = find(parent, parent[x]);
    }
    return parent[x];
}

int unite(int parent[], int rank[], int x, int y) {
    int px = find(parent, x), py = find(parent, y);
    if (px == py) return 0;
    
    if (rank[px] < rank[py]) {
        int temp = px; px = py; py = temp;
    }
    parent[py] = px;
    if (rank[px] == rank[py]) {
        rank[px]++;
    }
    return 1;
}

int minCostToSupplyWater(int n, int* wells, int wellsSize, int** pipes, int pipesSize, int* pipesColSize) {
    // Create edges array
    Edge* edges = malloc((n + pipesSize) * sizeof(Edge));
    int edgeCount = 0;
    
    // Add virtual source edges
    for (int i = 0; i < n; i++) {
        edges[edgeCount++] = (Edge){wells[i], 0, i + 1};
    }
    
    // Add pipe edges
    for (int i = 0; i < pipesSize; i++) {
        edges[edgeCount++] = (Edge){pipes[i][2], pipes[i][0], pipes[i][1]};
    }
    
    // Sort edges
    qsort(edges, edgeCount, sizeof(Edge), compare);
    
    // Union-Find
    int* parent = malloc((n + 1) * sizeof(int));
    int* rank = calloc(n + 1, sizeof(int));
    for (int i = 0; i <= n; i++) {
        parent[i] = i;
    }
    
    int totalCost = 0;
    int edgesUsed = 0;
    
    for (int i = 0; i < edgeCount && edgesUsed < n; i++) {
        if (unite(parent, rank, edges[i].u, edges[i].v)) {
            totalCost += edges[i].cost;
            edgesUsed++;
        }
    }
    
    free(edges);
    free(parent);
    free(rank);
    
    return totalCost;
}

Time & Space Complexity

Time Complexity

⏱️

O((m+n) log(m+n))

Sorting (m+n) edges takes O((m+n) log(m+n)), Union-Find operations are nearly O(1) with path compression

⚡ Linearithmic

Space Complexity

O(m+n)

Space for storing edges, Union-Find parent array, and rank array

⚡ Linearithmic Space

Constraints

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

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Minimum Spanning Tree with Virtual Source (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler