Trapping Rain Water

Author: volodimyr

297.serialise_and_desirialise_binary_tree/tree.go

@@ -1,6 +1,6 @@
 // 297. Serialize and Deserialize Binary Tree
 // Topics: 'String', 'Tree', 'Depth-First Search', 'Breadth-First Search', 'Design', 'Binary Tree'
-// Level: 'Medium'
+// Level: 'Hard'
 
 // Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.
 

42.trapping_rain_water/rain.go

@@ -0,0 +1,59 @@
+// 42. Trapping Rain Water
+// Topics: 'Array', 'Two Pointers', 'Dynamic Programming', 'Stack', 'Monotonic Stack'
+// Level: 'Hard'
+
+// Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it can trap after raining.
+
+// Example 1:
+
+// Input: height = [0,1,0,2,1,0,1,3,2,1,2,1]
+// Output: 6
+// Explanation: The above elevation map (black section) is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped.
+
+// Example 2:
+
+// Input: height = [4,2,0,3,2,5]
+// Output: 9
+
+// Constraints:
+
+//     n == height.length
+//     1 <= n <= 2 * 104
+//     0 <= height[i] <= 105
+
+package trappingrainwater
+
+func trap(height []int) int {
+	if len(height) < 2 {
+		return 0
+	}
+	R := len(height) - 1
+	L := 0
+	var sum int
+
+	maxr, maxl := R-1, L+1
+	for L < R {
+		if height[L] < height[R] {
+			var ocuppied int
+			for height[maxl] < height[L] && maxl != R {
+				ocuppied += height[maxl]
+				maxl++
+			}
+			sum += min(height[L], height[maxl]) * (maxl - L - 1)
+			sum -= ocuppied
+			L = maxl
+			maxl++
+		} else {
+			var occupied int
+			for height[maxr] < height[R] && maxr != L {
+				occupied += height[maxr]
+				maxr--
+			}
+			sum += min(height[R], height[maxr]) * (R - maxr - 1)
+			sum -= occupied
+			R = maxr
+			maxr--
+		}
+	}
+	return sum
+}

42.trapping_rain_water/rain_test.go

@@ -0,0 +1,101 @@
+package trappingrainwater
+
+import "testing"
+
+func TestTrap(t *testing.T) {
+	tests := []struct {
+		name   string
+		height []int
+		want   int
+	}{
+		{
+			name:   "example 0",
+			height: []int{5, 4, 1, 2},
+			want:   1,
+		},
+		{
+			name:   "example 1",
+			height: []int{0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1},
+			want:   6,
+		},
+		{
+			name:   "example 2",
+			height: []int{4, 2, 0, 3, 2, 5},
+			want:   9,
+		},
+		{
+			name:   "no water trapped - flat",
+			height: []int{0, 0, 0, 0},
+			want:   0,
+		},
+		{
+			name:   "no water trapped - ascending",
+			height: []int{1, 2, 3, 4, 5},
+			want:   0,
+		},
+		{
+			name:   "no water trapped - descending",
+			height: []int{5, 4, 3, 2, 1},
+			want:   0,
+		},
+		{
+			name:   "single element",
+			height: []int{5},
+			want:   0,
+		},
+		{
+			name:   "two elements",
+			height: []int{3, 0},
+			want:   0,
+		},
+		{
+			name:   "simple valley",
+			height: []int{3, 0, 3},
+			want:   3,
+		},
+		{
+			name:   "multiple valleys",
+			height: []int{3, 0, 2, 0, 4},
+			want:   7,
+		},
+		{
+			name:   "complex pattern",
+			height: []int{5, 2, 1, 2, 1, 5},
+			want:   14,
+		},
+		{
+			name:   "all zeros",
+			height: []int{0, 0, 0},
+			want:   0,
+		},
+		{
+			name:   "peak in middle",
+			height: []int{2, 0, 2},
+			want:   2,
+		},
+		{
+			name:   "asymmetric walls",
+			height: []int{5, 1, 3},
+			want:   2,
+		},
+		{
+			name:   "long flat section",
+			height: []int{3, 0, 0, 6, 0, 0, 3},
+			want:   12,
+		},
+		{
+			name:   "water at different levels",
+			height: []int{4, 2, 3},
+			want:   1,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := trap(tt.height)
+			if got != tt.want {
+				t.Errorf("trap(%v) = %v, want %v", tt.height, got, tt.want)
+			}
+		})
+	}
+}