[LeetCode] 1488. Avoid Flood in The City

Your country has an infinite number of lakes. Initially, all the lakes are empty, but when it rains over the nth lake, the nth lake becomes full of water. If it rains over a lake which is full of water, there will be a flood. Your goal is to avoid the flood in any lake.

Given an integer array rains where:

• rains[i] > 0 means there will be rains over the rains[i] lake.
• rains[i] == 0 means there are no rains this day and you can choose one lake this day and dry it.

Return an array ans where:

• ans.length == rains.length
• ans[i] == -1 if rains[i] > 0.
• ans[i] is the lake you choose to dry in the ith day if rains[i] == 0.

If there are multiple valid answers return any of them. If it is impossible to avoid flood return an empty array.

Notice that if you chose to dry a full lake, it becomes empty, but if you chose to dry an empty lake, nothing changes. (see example 4)

Example 1:

Input: rains = [1,2,3,4]
Output: [-1,-1,-1,-1]
Explanation: After the first day full lakes are [1]
After the second day full lakes are [1,2]
After the third day full lakes are [1,2,3]
After the fourth day full lakes are [1,2,3,4]
There's no day to dry any lake and there is no flood in any lake.

Example 2:

Input: rains = [1,2,0,0,2,1]
Output: [-1,-1,2,1,-1,-1]
Explanation: After the first day full lakes are [1]
After the second day full lakes are [1,2]
After the third day, we dry lake 2. Full lakes are [1]
After the fourth day, we dry lake 1. There is no full lakes.
After the fifth day, full lakes are [2].
After the sixth day, full lakes are [1,2].
It is easy that this scenario is flood-free. [-1,-1,1,2,-1,-1] is another acceptable scenario.

Example 3:

Input: rains = [1,2,0,1,2]
Output: []
Explanation: After the second day, full lakes are  [1,2]. We have to dry one lake in the third day.
After that, it will rain over lakes [1,2]. It's easy to prove that no matter which lake you choose to dry in the 3rd day, the other one will flood.

Example 4:

Input: rains = [69,0,0,0,69]
Output: [-1,69,1,1,-1]
Explanation: Any solution on one of the forms [-1,69,x,y,-1], [-1,x,69,y,-1] or [-1,x,y,69,-1] is acceptable where 1 <= x,y <= 10^9

Example 5:

Input: rains = [10,20,20]
Output: []
Explanation: It will rain over lake 20 two consecutive days. There is no chance to dry any lake.

Constraints:

• 1 <= rains.length <= 10^5
• 0 <= rains[i] <= 10^9

避免洪水泛滥。

你的国家有无数个湖泊，所有湖泊一开始都是空的。当第 n 个湖泊下雨的时候，如果第 n 个湖泊是空的，那么它就会装满水，否则这个湖泊会发生洪水。你的目标是避免任意一个湖泊发生洪水。

给你一个整数数组 rains ，其中：

rains[i] > 0 表示第 i 天时，第 rains[i] 个湖泊会下雨。
rains[i] == 0 表示第 i 天没有湖泊会下雨，你可以选择 一个 湖泊并 抽干 这个湖泊的水。
请返回一个数组 ans ，满足：

ans.length == rains.length
如果 rains[i] > 0 ，那么ans[i] == -1 。
如果 rains[i] == 0 ，ans[i] 是你第 i 天选择抽干的湖泊。
如果有多种可行解，请返回它们中的 任意一个 。如果没办法阻止洪水，请返回一个 空的数组 。

请注意，如果你选择抽干一个装满水的湖泊，它会变成一个空的湖泊。但如果你选择抽干一个空的湖泊，那么将无事发生（详情请看示例 4）。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/avoid-flood-in-the-city
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

这个题没有什么特别的思路，我这里提供一个可行的做法，会用到hashmap和treeset。其中hashmap存<下雨的湖泊，下雨天index>，treeset存晴天的index。为什么用treeset而不是hashset存晴天的index是因为treeset里面的item可以做到有序，这个到后面很有用。开始遍历input数组

• 如果rains[i] == 0，说明那一天不下雨，则用treeset记录这个晴天的index
• 如果rains[i]不是0，则说明那一天某个湖泊会下雨，在结果集里面需要存入-1，同时，分如下几种情况再讨论
  • 如果rains[i]不存在于hashmap，即某个湖泊还未下过雨，则将这个湖泊的index和下雨天的index存入hashmap
  • 如果rains[i]存在于hashmap，说明某个湖泊已经下过雨了，此时需要试着找一下是否有0（不下雨的天）在这个湖泊第一次下雨之后，将rains[i]这个湖泊的水抽干，否则整体就要返回[0]了（说明抗洪失败）。因为treeset存的是晴天的index，所以这个找0的方式是去看treeset是否为空或者treeset.ceiling(day)是否有值返回，若有则找到一个晴天来抽水，若没有则抗洪失败

treeset的ceiling方法是去treeset找一个最小的大于day的元素，也就是去找某个湖泊第一次下雨之后最近的晴天。其余的解释请参考注释。

时间O(n)

空间O(n)

Java实现

class Solution {
    public int[] avoidFlood(int[] rains) {
        int n = rains.length;
        int[] res = new int[n];
        // <下雨的湖泊，下雨天index>
        Map<Integer, Integer> map = new HashMap<>();
        // treeset存不下雨天index
        TreeSet<Integer> treeset = new TreeSet<>();
        for (int i = 0; i < n; i++) {
            if (rains[i] != 0) {
                res[i] = -1;
                // 如果某个湖泊又下雨了
                if (map.containsKey(rains[i])) {
                    // 找到这个湖泊第一次下雨天的index
                    int day = map.get(rains[i]);
                    // 如果treeset为空或者在day之后没有不下雨的天数则说明会发洪水
                    if (treeset.isEmpty() || treeset.ceiling(day) == null) {
                        return new int[0];
                    }
                    // 找到了某一天把水抽干
                    res[treeset.ceiling(day)] = rains[i];
                    // 记录当前湖泊最新一次的下雨天index
                    map.put(rains[i], i);
                    // 从treeset中去掉已经用掉的不下雨天index
                    treeset.remove(treeset.ceiling(day));
                } else {
                    map.put(rains[i], i);
                }
            } else {
                treeset.add(i);
            }
        }

        // 不下雨的天数全都去抽干第一个水池
        for (int i = 0; i < n; i++) {
            if (res[i] == 0) {
                res[i] = 1;
            }
        }
        return res;
    }
}

LeetCode 题目总结