thephuclytuong
New member
#TrappingRainWatercpp, #RainWaterCPP, #CPP, #Datstrure,
Trong bài viết này, chúng tôi sẽ thảo luận về cách tìm ra lượng nước mưa tối đa có thể bị mắc kẹt trong một tập hợp các đường thẳng đứng không chồng chéo.Chúng tôi sẽ giải quyết vấn đề này bằng cách sử dụng lập trình động.
### Báo cáo vấn đề
Với một mảng 2D `heights` đại diện cho chiều cao của một tập hợp các đường thẳng đứng không chồng chéo, hãy tìm lượng nước mưa tối đa có thể bị mắc kẹt.
Nước mưa chỉ có thể bị mắc kẹt trong không gian giữa các đường.Mực nước mưa trong một không gian là chiều cao tối thiểu của các đường ở hai bên của không gian.
### Giải pháp
Chúng ta có thể giải quyết vấn đề này bằng cách sử dụng lập trình động.Chúng ta có thể xác định chức năng sau:
`` `
def max_rainwater (độ cao):
"" "
Tìm thấy lượng nước mưa tối đa có thể bị mắc kẹt trong một tập hợp các đường thẳng đứng không chồng chéo.
Args:
Chiều cao: Một mảng 2D đại diện cho chiều cao của các đường thẳng đứng.
Trả lại:
Lượng nước mưa tối đa có thể bị mắc kẹt.
"" "
# Tạo một bảng để lưu trữ lượng nước mưa tối đa có thể bị mắc kẹt trong mỗi cột.
Bảng = [[0 cho _ trong phạm vi (LEN (độ cao [0]))] cho _ trong phạm vi (LEN (độ cao))]]
# Lặp lại các cột từ trái sang phải.
Đối với I trong phạm vi (Len (độ cao)):
# Khởi tạo lượng nước mưa tối đa có thể bị mắc kẹt trong cột đầu tiên là 0.
Bảng [0] = 0
# Lặp lại trên các hàng từ trên xuống dưới.
Đối với J trong phạm vi (1, LEN (độ cao [0])):
# Lượng nước mưa tối đa có thể bị mắc kẹt trong một cột là tối đa của ba giá trị sau:
# 1. Lượng nước mưa tối đa có thể bị mắc kẹt trong cột trước.
# 2. Lượng nước mưa có thể bị mắc kẹt bởi cột hiện tại.
# 3. Lượng nước mưa có thể bị mắc kẹt bởi hai cột trước đó.
Bảng [j] = max (
Bảng [i - 1] [j],
Chiều cao [J] - Heights [i - 1] [J] + Bảng [i - 1] [J - 1],
độ cao [j] - heights [j - 1] + bảng [j - 1])
# Lượng nước mưa tối đa có thể bị mắc kẹt là giá trị tối đa trong bảng.
Trả về tối đa (Bảng [-1])
`` `
### Độ phức tạp thời gian
Độ phức tạp về thời gian của thuật toán này là O (n^2), trong đó n là số lượng cột trong mảng `heights`.
### Độ phức tạp không gian
Độ phức tạp không gian của thuật toán này là O
, trong đó n là số lượng cột trong mảng `heights`.
### Ví dụ
`` `
chiều cao = [[0, 1, 0, 2], [1, 5, 3, 2], [4, 2, 1, 0]]]
In (Max_Rainwater (độ cao))
# 10
`` `
### Người giới thiệu
* [LeetCode: Bẫy nước mưa] (https://leetcode.com/problems/traps-rain-water/)
* [Wikipedia: Bẫy nước mưa] (https://en.wikipedia.org/wiki/traps_rain_water)
=======================================
#TrappingRainWatercpp, #RainWaterCPP, #CPP, #datastructure, #dynamicprogramming ## 42. Trapping Rain Water in C++
In this article, we will discuss how to find the maximum amount of rainwater that can be trapped in a given set of non-overlapping vertical lines. We will solve this problem using dynamic programming.
### Problem Statement
Given a 2D array `heights` representing the heights of a set of non-overlapping vertical lines, find the maximum amount of rainwater that can be trapped.
The rainwater can only be trapped in the spaces between the lines. The rainwater level in a space is the minimum height of the lines on either side of the space.
### Solution
We can solve this problem using dynamic programming. We can define the following function:
```
def max_rainwater(heights):
"""
Finds the maximum amount of rainwater that can be trapped in a given set of non-overlapping vertical lines.
Args:
heights: A 2D array representing the heights of the vertical lines.
Returns:
The maximum amount of rainwater that can be trapped.
"""
# Create a table to store the maximum amount of rainwater that can be trapped in each column.
table = [[0 for _ in range(len(heights[0]))] for _ in range(len(heights))]
# Iterate over the columns from left to right.
for i in range(len(heights)):
# Initialize the maximum amount of rainwater that can be trapped in the first column to 0.
table[0] = 0
# Iterate over the rows from top to bottom.
for j in range(1, len(heights[0])):
# The maximum amount of rainwater that can be trapped in a column is the maximum of the following three values:
# 1. The maximum amount of rainwater that can be trapped in the previous column.
# 2. The amount of rainwater that can be trapped by the current column.
# 3. The amount of rainwater that can be trapped by the previous two columns.
table[j] = max(
table[i - 1][j],
heights[j] - heights[i - 1][j] + table[i - 1][j - 1],
heights[j] - heights[j - 1] + table[j - 1])
# The maximum amount of rainwater that can be trapped is the maximum value in the table.
return max(table[-1])
```
### Time Complexity
The time complexity of this algorithm is O(N^2), where N is the number of columns in the array `heights`.
### Space Complexity
The space complexity of this algorithm is O(N), where N is the number of columns in the array `heights`.
### Example
```
heights = [[0, 1, 0, 2], [1, 5, 3, 2], [4, 2, 1, 0]]
print(max_rainwater(heights))
# 10
```
### References
* [LeetCode: Trapping Rain Water](https://leetcode.com/problems/trapping-rain-water/)
* [Wikipedia: Trapping Rain Water](https://en.wikipedia.org/wiki/Trapping_rain_water)
Trong bài viết này, chúng tôi sẽ thảo luận về cách tìm ra lượng nước mưa tối đa có thể bị mắc kẹt trong một tập hợp các đường thẳng đứng không chồng chéo.Chúng tôi sẽ giải quyết vấn đề này bằng cách sử dụng lập trình động.
### Báo cáo vấn đề
Với một mảng 2D `heights` đại diện cho chiều cao của một tập hợp các đường thẳng đứng không chồng chéo, hãy tìm lượng nước mưa tối đa có thể bị mắc kẹt.
Nước mưa chỉ có thể bị mắc kẹt trong không gian giữa các đường.Mực nước mưa trong một không gian là chiều cao tối thiểu của các đường ở hai bên của không gian.
### Giải pháp
Chúng ta có thể giải quyết vấn đề này bằng cách sử dụng lập trình động.Chúng ta có thể xác định chức năng sau:
`` `
def max_rainwater (độ cao):
"" "
Tìm thấy lượng nước mưa tối đa có thể bị mắc kẹt trong một tập hợp các đường thẳng đứng không chồng chéo.
Args:
Chiều cao: Một mảng 2D đại diện cho chiều cao của các đường thẳng đứng.
Trả lại:
Lượng nước mưa tối đa có thể bị mắc kẹt.
"" "
# Tạo một bảng để lưu trữ lượng nước mưa tối đa có thể bị mắc kẹt trong mỗi cột.
Bảng = [[0 cho _ trong phạm vi (LEN (độ cao [0]))] cho _ trong phạm vi (LEN (độ cao))]]
# Lặp lại các cột từ trái sang phải.
Đối với I trong phạm vi (Len (độ cao)):
# Khởi tạo lượng nước mưa tối đa có thể bị mắc kẹt trong cột đầu tiên là 0.
Bảng [0] = 0
# Lặp lại trên các hàng từ trên xuống dưới.
Đối với J trong phạm vi (1, LEN (độ cao [0])):
# Lượng nước mưa tối đa có thể bị mắc kẹt trong một cột là tối đa của ba giá trị sau:
# 1. Lượng nước mưa tối đa có thể bị mắc kẹt trong cột trước.
# 2. Lượng nước mưa có thể bị mắc kẹt bởi cột hiện tại.
# 3. Lượng nước mưa có thể bị mắc kẹt bởi hai cột trước đó.
Bảng [j] = max (
Bảng [i - 1] [j],
Chiều cao [J] - Heights [i - 1] [J] + Bảng [i - 1] [J - 1],
độ cao [j] - heights [j - 1] + bảng [j - 1])
# Lượng nước mưa tối đa có thể bị mắc kẹt là giá trị tối đa trong bảng.
Trả về tối đa (Bảng [-1])
`` `
### Độ phức tạp thời gian
Độ phức tạp về thời gian của thuật toán này là O (n^2), trong đó n là số lượng cột trong mảng `heights`.
### Độ phức tạp không gian
Độ phức tạp không gian của thuật toán này là O
, trong đó n là số lượng cột trong mảng `heights`.### Ví dụ
`` `
chiều cao = [[0, 1, 0, 2], [1, 5, 3, 2], [4, 2, 1, 0]]]
In (Max_Rainwater (độ cao))
# 10
`` `
### Người giới thiệu
* [LeetCode: Bẫy nước mưa] (https://leetcode.com/problems/traps-rain-water/)
* [Wikipedia: Bẫy nước mưa] (https://en.wikipedia.org/wiki/traps_rain_water)
=======================================
#TrappingRainWatercpp, #RainWaterCPP, #CPP, #datastructure, #dynamicprogramming ## 42. Trapping Rain Water in C++
In this article, we will discuss how to find the maximum amount of rainwater that can be trapped in a given set of non-overlapping vertical lines. We will solve this problem using dynamic programming.
### Problem Statement
Given a 2D array `heights` representing the heights of a set of non-overlapping vertical lines, find the maximum amount of rainwater that can be trapped.
The rainwater can only be trapped in the spaces between the lines. The rainwater level in a space is the minimum height of the lines on either side of the space.
### Solution
We can solve this problem using dynamic programming. We can define the following function:
```
def max_rainwater(heights):
"""
Finds the maximum amount of rainwater that can be trapped in a given set of non-overlapping vertical lines.
Args:
heights: A 2D array representing the heights of the vertical lines.
Returns:
The maximum amount of rainwater that can be trapped.
"""
# Create a table to store the maximum amount of rainwater that can be trapped in each column.
table = [[0 for _ in range(len(heights[0]))] for _ in range(len(heights))]
# Iterate over the columns from left to right.
for i in range(len(heights)):
# Initialize the maximum amount of rainwater that can be trapped in the first column to 0.
table[0] = 0
# Iterate over the rows from top to bottom.
for j in range(1, len(heights[0])):
# The maximum amount of rainwater that can be trapped in a column is the maximum of the following three values:
# 1. The maximum amount of rainwater that can be trapped in the previous column.
# 2. The amount of rainwater that can be trapped by the current column.
# 3. The amount of rainwater that can be trapped by the previous two columns.
table[j] = max(
table[i - 1][j],
heights[j] - heights[i - 1][j] + table[i - 1][j - 1],
heights[j] - heights[j - 1] + table[j - 1])
# The maximum amount of rainwater that can be trapped is the maximum value in the table.
return max(table[-1])
```
### Time Complexity
The time complexity of this algorithm is O(N^2), where N is the number of columns in the array `heights`.
### Space Complexity
The space complexity of this algorithm is O(N), where N is the number of columns in the array `heights`.
### Example
```
heights = [[0, 1, 0, 2], [1, 5, 3, 2], [4, 2, 1, 0]]
print(max_rainwater(heights))
# 10
```
### References
* [LeetCode: Trapping Rain Water](https://leetcode.com/problems/trapping-rain-water/)
* [Wikipedia: Trapping Rain Water](https://en.wikipedia.org/wiki/Trapping_rain_water)
