# Solution For Avoid Flood In The City

The “Avoid Flood in The City” problem on LeetCode requires finding a solution to prevent floods in a city where there are multiple rainfalls. The problem can be solved using a hash table and a set.

The steps to solve the problem are:

Step 1: Create an empty hash table to store all the lakes and their corresponding index.

Step 2: Traverse the given array and check if there is a rainfall in the current day.

Step 3: If there is a rainfall, check if the corresponding lake is empty or not.

Step 4: If the lake is empty, add the lake to the hash table with its index as the value.

Step 5: If the lake is not empty, check if there is any previously visited day where the same lake was empty.

Step 6: If there exists a previously visited day where the same lake was empty, find the minimum index of such an empty day.

Step 7: If there is no previously visited day where the same lake was empty, then it is not possible to avoid the flood, so return an empty array.

Step 8: If there is a previously visited day where the same lake was empty, then fill the lake on the current day with water and remove the empty day from the hash table.

Step 9: Continue traversing the array until the end.

Step 10: After traversing the array, if there are still empty days remaining in the hash table, then fill them with water on the last day.

Step 11: Return the final result.

Here is the Python code for the solution:

“`
def avoidFlood(rains):

lakes = {}
result = [-1] * len(rains)

for i, lake in enumerate(rains):

if lake == 0:
result[i] = 1

else:
if lake in lakes:

if not lakes[lake]:
return []

else:
empty_day = min([x for x in lakes[lake] if x > i])
lakes[lake].remove(empty_day)
result[empty_day] = lake

lakes[lake] = lakes.get(lake, []) + [i]

for lake in lakes:
for day in lakes[lake]:
result[day] = lake

return result

“`

The time complexity of this solution is O(nlogn) due to the use of the min function. The space complexity is O(n) due to the use of the hash table and the set.

## Step by Step Implementation For Avoid Flood In The City

class Solution {
public int[] avoidFlood(int[] rains) {
}
}
from collections import deque

class Solution:
def avoidFlood(self, rains: List[int]) -> List[int]:
# create a dict to store the position of each rain
rain_pos = {}
# create a set to store the days with no rain
no_rain = set()
# create a queue to store the days with rain
rain_q = deque()
# create a list to store the result
res = []

# loop through the rains list
for i, rain in enumerate(rains):
# if it's not rain, add the day to the no_rain set
if rain == 0:
# if it's rain, add the day and position to the rain_pos dict
else:
rain_pos[rain] = i
rain_q.append(rain)

# loop through the rains list again
for i, rain in enumerate(rains):
# if it's rain, pop the rain from the queue
if rain:
rains.pop(0)
# if the rain is in the no_rain set, that means we can drain it
if rain in no_rain:
no_rain.remove(rain)
res.append(1)
# if the rain is not in the no_rain set, that means we can't drain it
else:
# return -1 since it's not possible to avoid flood
return -1
# if it's not rain, add the day to the res list
else:
res.append(0)

return res

var avoidFlood = function( rains ) {

// create an empty map to store "lake" and its last rain day
let map = {};

// create an empty set to store the "dry" days
let set = new Set();

// create an empty array to store the final result
let ans = [];

// loop through the rains array
for ( let i=0; i a-b );

// loop through the map
for ( let key in map ) {

// if the set is empty, return []
if ( dry.length === 0 ) {
return [];
}

// if the last rain day of this "lake" is before the first "dry" day, it's safe to drain it
if ( map[key] < dry[0] ) {

// update the ans array
ans[map[key]] = -1;

// remove the first "dry" day from the set
dry.shift();

} else {

// otherwise, it's not safe to drain it

// update the ans array
ans[dry[0]] = Number(key);

// remove the first "dry" day from the set
dry.shift();

// update the last rain day of this "lake" in the map
map[key] = dry[0];
}
}

// return the ans array
return ans;

};
The problem can be found here: https://leetcode.com/problems/avoid-flood-in-the-city/

One possible solution is as follows:

vector avoidFlood(vector& rains) {

//unordered_map to keep track of the position of each rain day
unordered_map rain_days;

//set to keep track of the rain days that have been dried out
set dried_out;

//result vector
vector res;

//loop through the rains vector
for(int i = 0; i < rains.size(); i++){

//if the current day is a rain day
if(rains[i] != 0){

//if we have already seen this rain day before
if(rain_days.count(rains[i])){

//if the day before the current day has been dried out
if(dried_out.count(rains[i] - 1)){

//dried out day is no longer available, so remove it from the set
dried_out.erase(rains[i] - 1);

//add the current rain day to the result vector
res.push_back(rains[i]);

//mark the current rain day as dried out
dried_out.insert(rains[i]);
}

//if the day before the current day has not been dried out
else{

//return an empty vector since we are not able to avoid flooding
return {};
}
}

//if we have not seen this rain day before
else{

//add the current rain day to the result vector
res.push_back(-1);

//add the current rain day to the map
rain_days[rains[i]] = i;
}
}

//if the current day is not a rain day
else{

//add the current day to the result vector
res.push_back(1);

//mark the current day as dried out
dried_out.insert(i);
}
}

//return the result vector
return res;
}
using System;
using System.Collections.Generic;

public class Solution {

public int[] AvoidFlood(int[] rains) {

// check input
if (rains == null || rains.Length == 0) return new int[0];

// initialize variables
int n = rains.Length;
int[] res = new int[n];
Dictionary lake = new Dictionary();
HashSet dryDay = new HashSet();

// fill in the result array
for (int i = 0; i < n; i++) {

int rain = rains[i];

// if it's a dry day, add it to the set
if (rain == 0) {
continue;
}

// if we've seen this lake before, it means it will flood
if (lake.ContainsKey(rain)) {

// get the index of the last dry day before the lake floods
int lastDryDay = -1;
for (int j = lake[rain] + 1; j < i; j++) {
if (dryDay.Contains(j)) {
lastDryDay = j;
break;
}
}

// if there's no dry day before the lake floods, return empty array
if (lastDryDay == -1) return new int[0];

// otherwise, use the dry day to drain the lake
res[lastDryDay] = rain;
dryDay.Remove(lastDryDay);
}

// add the lake to the map
lake[rain] = i;
res[i] = -1;
}

return res;
}
}

Scroll to Top

## Top 100 Leetcode Practice Problems In Java

Get 30% Off Instantly!
[gravityforms id="5" description="false" titla="false" ajax="true"]