Avoid Flood in The City - Practice Coding Problems

Avoid Flood in The City - Problem

Array Hash Table Binary Search Greedy Heap (Priority Queue) Medium

Flood Prevention Simulation

You're managing a water system for a city with 10⁹ lakes. Initially, all lakes are empty. Your task is to prevent flooding by strategically drying lakes on no-rain days.

How it works:
• When rains[i] > 0: It rains on lake number rains[i], filling it completely
• When rains[i] == 0: No rain - you must choose one lake to dry
• If it rains on an already full lake, there's a flood (game over!)

Goal: Return an array where:
• ans[i] = -1 for rainy days
• ans[i] = lake_number for the lake you dry on no-rain days

If flooding is unavoidable, return an empty array. Multiple valid solutions may exist.

Input & Output

basic_case.py — Python

$ Input: rains = [1, 2, 3, 4]

› Output: [-1, -1, -1, -1]

💡 Note: All days have rain, no dry days to worry about. Each lake gets filled once, so no floods occur.

dry_and_flood.py — Python

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

› Output: [-1, -1, 2, 1, -1, -1]

💡 Note: Lake 2 rains on day 4, so we must dry it on day 2. Lake 1 rains on day 5, so we dry it on day 3. This prevents both floods.

impossible_case.py — Python

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

› Output: []

💡 Note: Lake 1 is full after day 0, rains again on day 3. Lake 2 is full after day 1, rains again on day 4. Only one dry day (day 2) cannot prevent both floods.

Visualization

Tap to expand

Understanding the Visualization

Monitor Weather

Track which areas are flooded and when storms are coming

Detect Threat

Identify when a storm will hit an already flooded area

Deploy Crews

Use binary search to find the best time to send drainage crews

Prevent Disaster

Complete drainage before the next storm hits

Key Takeaway

🎯 Key Insight: Use greedy strategy with binary search - always handle the most urgent flood threat first by finding the earliest available dry day after a lake was filled.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Binary search operations on dry days for each lake

⚡ Linearithmic

Space Complexity

O(n)

Space for tracking full lakes and dry days

⚡ Linearithmic Space

Constraints

1 ≤ rains.length ≤ 10⁵
0 ≤ rains[i] ≤ 10⁹
rains[i] = 0 means no rain (dry day)
rains[i] > 0 means rain on lake rains[i]

Asked in

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

The optimal solution uses a greedy approach with binary search. Track full lakes and available dry days. When a lake is about to flood, use binary search to find the earliest available dry day after it was filled. This O(n log n) solution ensures we prevent floods by making optimal timing decisions.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy with Binary Search (Optimal)	O(n log n)	O(n)	Track full lakes and use binary search to find optimal drying schedule
Brute Force (Try All Combinations)	O(k^d)	O(n)	Try all possible ways to assign lakes to dry days
Priority Queue + Binary Search	O(n log n)	O(n)	Use priority queue to track urgent lakes and binary search for optimal timing

Greedy with Binary Search (Optimal) — Algorithm Steps

Use a set to track currently full lakes
Use binary search to find the next rain day for each full lake
On dry days, greedily dry the lake with earliest next rain
Store dry days in a sorted set for efficient binary search

Visualization

Tap to expand

Step-by-Step Walkthrough

Track State

Maintain full lakes and available dry days

Detect Conflict

Rain on full lake triggers search

Binary Search

Find earliest dry day after lake was filled

Greedy Choice

Use that dry day to prevent flood

Code -

solution.c — C

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

#define MAX_N 100000

typedef struct {
    int lake;
    int day;
} LakeDay;

int compare(const void* a, const void* b) {
    return ((int*)a)[0] - ((int*)b)[0];
}

int* avoidFlood(int* rains, int rainsSize, int* returnSize) {
    *returnSize = rainsSize;
    int* result = (int*)malloc(rainsSize * sizeof(int));
    for (int i = 0; i < rainsSize; i++) result[i] = -1;
    
    LakeDay fullLakes[MAX_N];
    int fullCount = 0;
    int dryDays[MAX_N];
    int dryCount = 0;
    
    for (int i = 0; i < rainsSize; i++) {
        if (rains[i] == 0) {
            dryDays[dryCount++] = i;
        } else {
            int lake = rains[i];
            
            // Check if lake is already full
            int foundIdx = -1;
            for (int j = 0; j < fullCount; j++) {
                if (fullLakes[j].lake == lake) {
                    foundIdx = j;
                    break;
                }
            }
            
            if (foundIdx != -1) {
                int filledDay = fullLakes[foundIdx].day;
                
                // Find next dry day
                int dryIdx = -1;
                for (int j = 0; j < dryCount; j++) {
                    if (dryDays[j] > filledDay) {
                        dryIdx = j;
                        break;
                    }
                }
                
                if (dryIdx == -1) {
                    *returnSize = 0;
                    free(result);
                    return NULL;
                }
                
                result[dryDays[dryIdx]] = lake;
                
                // Remove dry day
                for (int j = dryIdx; j < dryCount - 1; j++) {
                    dryDays[j] = dryDays[j + 1];
                }
                dryCount--;
                
                // Remove from full lakes
                for (int j = foundIdx; j < fullCount - 1; j++) {
                    fullLakes[j] = fullLakes[j + 1];
                }
                fullCount--;
            }
            
            fullLakes[fullCount].lake = lake;
            fullLakes[fullCount].day = i;
            fullCount++;
        }
    }
    
    // Fill remaining dry days
    for (int i = 0; i < dryCount; i++) {
        result[dryDays[i]] = 1;
    }
    
    return result;
}

int main() {
    int rains[] = {1, 2, 0, 0, 2, 1};
    int returnSize;
    int* result = avoidFlood(rains, 6, &returnSize);
    
    if (result) {
        for (int i = 0; i < returnSize; i++) {
            printf("%d ", result[i]);
        }
        free(result);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Binary search operations on dry days for each lake

⚡ Linearithmic

Space Complexity

O(n)

Space for tracking full lakes and dry days

⚡ Linearithmic Space

Constraints

1 ≤ rains.length ≤ 10⁵
0 ≤ rains[i] ≤ 10⁹
rains[i] = 0 means no rain (dry day)
rains[i] > 0 means rain on lake rains[i]

52.8K Views

Medium Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Greedy with Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler