From 582e5e9efe7e5a2ff500747b069f052dba6ec7ae Mon Sep 17 00:00:00 2001 From: 0xff-dev Date: Tue, 7 Oct 2025 17:10:57 +0800 Subject: [PATCH] Add solution and test-cases for problem 1488 --- .../1488.Avoid-Flood-in-The-City/README.md | 61 +++++++++++++++ .../1488.Avoid-Flood-in-The-City/Solution.go | 74 ++++++++++++++++++- .../Solution_test.go | 14 ++-- 3 files changed, 141 insertions(+), 8 deletions(-) create mode 100644 leetcode/1401-1500/1488.Avoid-Flood-in-The-City/README.md diff --git a/leetcode/1401-1500/1488.Avoid-Flood-in-The-City/README.md b/leetcode/1401-1500/1488.Avoid-Flood-in-The-City/README.md new file mode 100644 index 000000000..570aa9cb3 --- /dev/null +++ b/leetcode/1401-1500/1488.Avoid-Flood-in-The-City/README.md @@ -0,0 +1,61 @@ +# [1488.Avoid Flood in The City][title] + +## Description +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 that is full of water, there will be a **flood**. Your goal is to avoid floods 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. + +**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. +``` + +## 结语 + +如果你同我一样热爱数据结构、算法、LeetCode，可以关注我 GitHub 上的 LeetCode 题解：[awesome-golang-algorithm][me] + +[title]: https://leetcode.com/problems/avoid-flood-in-the-city +[me]: https://github.com/kylesliu/awesome-golang-algorithm diff --git a/leetcode/1401-1500/1488.Avoid-Flood-in-The-City/Solution.go b/leetcode/1401-1500/1488.Avoid-Flood-in-The-City/Solution.go index d115ccf5e..4368584b1 100755 --- a/leetcode/1401-1500/1488.Avoid-Flood-in-The-City/Solution.go +++ b/leetcode/1401-1500/1488.Avoid-Flood-in-The-City/Solution.go @@ -1,5 +1,77 @@ package Solution -func Solution(x bool) bool { +import "container/heap" + +// 记录未来即将出现的lake +type lakeState struct { + lake int + nextDay int +} + +type lakeHeap struct { + data []*lakeState +} + +func (l *lakeHeap) Len() int { + return len(l.data) +} + +func (l *lakeHeap) Swap(i, j int) { + l.data[i], l.data[j] = l.data[j], l.data[i] +} + +func (l *lakeHeap) Less(i, j int) bool { + a, b := l.data[i], l.data[j] + return a.nextDay < b.nextDay +} + +func (l *lakeHeap) Push(x any) { + l.data = append(l.data, x.(*lakeState)) +} + +func (l *lakeHeap) Pop() any { + ll := len(l.data) + x := l.data[ll-1] + l.data = l.data[:ll-1] return x } + +func Solution(rains []int) []int { + l := len(rains) + days := make(map[int][]int) + // 记录走到那一天了 + indies := make(map[int]int) + for index, rain := range rains { + if rain == 0 { + continue + } + days[rain] = append(days[rain], index) + indies[rain] = 0 + } + full := make(map[int]bool) + h := &lakeHeap{data: make([]*lakeState, 0)} + ret := make([]int, l) + for index, lake := range rains { + if lake > 0 { + if full[lake] { + // 满 + return []int{} + } + full[lake] = true + ret[index] = -1 + if nextIndex := indies[lake] + 1; nextIndex < len(days[lake]) { + indies[lake]++ + heap.Push(h, &lakeState{lake: lake, nextDay: days[lake][nextIndex]}) + } + continue + } + ret[index] = 1 + if h.Len() > 0 { + top := heap.Pop(h).(*lakeState) + ret[index] = top.lake + delete(full, top.lake) + } + } + // 1, 2, 0, 2, 3, 0, 1 + return ret +} diff --git a/leetcode/1401-1500/1488.Avoid-Flood-in-The-City/Solution_test.go b/leetcode/1401-1500/1488.Avoid-Flood-in-The-City/Solution_test.go index 14ff50eb4..f0ba80aa5 100755 --- a/leetcode/1401-1500/1488.Avoid-Flood-in-The-City/Solution_test.go +++ b/leetcode/1401-1500/1488.Avoid-Flood-in-The-City/Solution_test.go @@ -10,12 +10,12 @@ func TestSolution(t *testing.T) { // 测试用例 cases := []struct { name string - inputs bool - expect bool + inputs []int + expect []int }{ - {"TestCase", true, true}, - {"TestCase", true, true}, - {"TestCase", false, false}, + {"TestCase1", []int{1, 2, 3, 4}, []int{-1, -1, -1, -1}}, + {"TestCase2", []int{1, 2, 0, 0, 2, 1}, []int{-1, -1, 2, 1, -1, -1}}, + {"TestCase3", []int{1, 2, 0, 1, 2}, []int{}}, } // 开始测试 @@ -30,10 +30,10 @@ func TestSolution(t *testing.T) { } } -// 压力测试 +// 压力测试 func BenchmarkSolution(b *testing.B) { } -// 使用案列 +// 使用案列 func ExampleSolution() { }