# 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) { // your code goes here } }

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: no_rain.add(i) # 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

Your answer should be submitted in a .js file 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; ia-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: vectoravoidFlood(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]; Dictionarylake = 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) { dryDay.Add(i); 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; } }