# Container With Most Water

The "Container With Most Water" problem is a well-known question in the field of algorithms and data structures, particularly emphasizing the use of the two-pointer technique. This problem focuses on finding an optimal solution by understanding how to efficiently navigate the space of possible solutions. Let's explore this problem from its basic principles.

### Problem Statement:

1. Input: An array of non-negative integers, where each integer represents the height of a line drawn at that point.
2. Goal: Find two lines, which, together with the x-axis, form a container that would hold the greatest amount of water.

### Fundamental Concepts:

• Array: A linear data structure that holds a collection of elements.
• Volume Calculation: The amount of water a container can hold is determined by the distance between lines (width) and the height of the shorter line (since the water would overflow over the shorter line).

### Solution Approach:

1. Two-Pointer Technique:

• Idea: Start with two pointers, one at the beginning and one at the end of the array. The initial container encompasses the entire array.
• Implementation: Move the pointers closer together, always moving the pointer that points to the shorter line.
• Rationale: By moving the shorter line, we are trying to find a taller line that can potentially hold more water. Moving the taller line would not help, as the height of the shorter line limits the container's capacity.
2. Volume Calculation:

• Formula: Volume = width * height
• Width: Distance between the two pointers.
• Height: Height of the shorter line (between the two pointers).
3. Time and Space Complexity:

• Time Complexity: O(n), where n is the length of the input array. Each element is visited only once.
• Space Complexity: O(1), as the solution requires a constant amount of space.

### Example Implementation in Python:

def max_area(height):
"""
Finds the maximum area of water that can be contained.

Args:
height (List[int]): An array of integers where each integer represents the height of a line.

Returns:
int: The maximum area of water that can be contained.
"""
max_area = 0
left, right = 0, len(height) - 1  # Two pointers

while left < right:
# Calculate the area and update max_area if necessary.
width = right - left
area = width * min(height[left], height[right])
max_area = max(max_area, area)

# Move the pointer pointing to the shorter line.
if height[left] < height[right]:
left += 1
else:
right -= 1

return max_area


This implementation:

• Initializes two pointers at the opposite ends of the array.
• Iterates until the pointers meet, at each step calculating the area formed between the lines at the pointers and updating the maximum area found.
• Moves the pointer at the shorter line towards the other pointer in each iteration, seeking a potentially taller line that could increase the area.